diff --git a/sql/base/auth_database.sql b/sql/base/auth_database.sql index 4aad22245..3a9bd6fb0 100644 --- a/sql/base/auth_database.sql +++ b/sql/base/auth_database.sql @@ -1,8 +1,8 @@ --- MySQL dump 10.11 +-- MySQL dump 10.13 Distrib 5.5.19, for Win64 (x86) -- --- Host: localhost Database: realmd +-- Host: localhost Database: auth -- ------------------------------------------------------ --- Server version 5.0.45-Debian_1ubuntu3.1-log +-- Server version 5.5.19 /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */; /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */; @@ -15,30 +15,6 @@ /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */; /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */; --- --- Table structure for table `account_access` --- - -DROP TABLE IF EXISTS `account_access`; -/*!40101 SET @saved_cs_client = @@character_set_client */; -/*!40101 SET character_set_client = utf8 */; -CREATE TABLE `account_access` ( - `id` int(11) unsigned NOT NULL, - `gmlevel` tinyint(3) unsigned NOT NULL, - `RealmID` int(11) NOT NULL default '-1', - PRIMARY KEY (`id`,`RealmID`) -) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC; -/*!40101 SET character_set_client = @saved_cs_client */; - --- --- Dumping data for table `account_access` --- - -LOCK TABLES `account_access` WRITE; -/*!40000 ALTER TABLE `account_access` DISABLE KEYS */; -/*!40000 ALTER TABLE `account_access` ENABLE KEYS */; -UNLOCK TABLES; - -- -- Table structure for table `account` -- @@ -47,26 +23,27 @@ DROP TABLE IF EXISTS `account`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `account` ( - `id` int(11) unsigned NOT NULL auto_increment COMMENT 'Identifier', - `username` varchar(32) NOT NULL default '', - `sha_pass_hash` varchar(40) NOT NULL default '', + `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Identifier', + `username` varchar(32) NOT NULL DEFAULT '', + `sha_pass_hash` varchar(40) NOT NULL DEFAULT '', `sessionkey` longtext, `v` longtext, `s` longtext, `email` text, - `joindate` timestamp NOT NULL default CURRENT_TIMESTAMP, - `last_ip` varchar(30) NOT NULL default '127.0.0.1', - `failed_logins` int(11) unsigned NOT NULL default '0', - `locked` tinyint(3) unsigned NOT NULL default '0', - `last_login` timestamp NOT NULL default '0000-00-00 00:00:00', - `online` tinyint(4) NOT NULL default '0', - `expansion` tinyint(3) unsigned NOT NULL default '2', - `mutetime` bigint(40) NOT NULL default '0', - `locale` tinyint(3) unsigned NOT NULL default '0', - `recruiter` int(11) NOT NULL default '0', - PRIMARY KEY (`id`), + `joindate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP, + `last_ip` varchar(30) NOT NULL DEFAULT '127.0.0.1', + `failed_logins` int(11) unsigned NOT NULL DEFAULT '0', + `locked` tinyint(3) unsigned NOT NULL DEFAULT '0', + `last_login` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00', + `online` tinyint(4) NOT NULL DEFAULT '0', + `expansion` tinyint(3) unsigned NOT NULL DEFAULT '2', + `mutetime` bigint(40) NOT NULL DEFAULT '0', + `locale` tinyint(3) unsigned NOT NULL DEFAULT '0', + `os` varchar(4) NOT NULL DEFAULT '', + `recruiter` int(11) NOT NULL DEFAULT '0', + PRIMARY KEY (`id`), UNIQUE KEY `idx_username` (`username`) -) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=DYNAMIC COMMENT='Account System'; +) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Account System'; /*!40101 SET character_set_client = @saved_cs_client */; -- @@ -78,6 +55,30 @@ LOCK TABLES `account` WRITE; /*!40000 ALTER TABLE `account` ENABLE KEYS */; UNLOCK TABLES; +-- +-- Table structure for table `account_access` +-- + +DROP TABLE IF EXISTS `account_access`; +/*!40101 SET @saved_cs_client = @@character_set_client */; +/*!40101 SET character_set_client = utf8 */; +CREATE TABLE `account_access` ( + `id` int(11) unsigned NOT NULL, + `gmlevel` tinyint(3) unsigned NOT NULL, + `RealmID` int(11) NOT NULL DEFAULT '-1', + PRIMARY KEY (`id`,`RealmID`) +) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC; +/*!40101 SET character_set_client = @saved_cs_client */; + +-- +-- Dumping data for table `account_access` +-- + +LOCK TABLES `account_access` WRITE; +/*!40000 ALTER TABLE `account_access` DISABLE KEYS */; +/*!40000 ALTER TABLE `account_access` ENABLE KEYS */; +UNLOCK TABLES; + -- -- Table structure for table `account_banned` -- @@ -86,13 +87,13 @@ DROP TABLE IF EXISTS `account_banned`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `account_banned` ( - `id` int(11) NOT NULL default '0' COMMENT 'Account id', - `bandate` bigint(40) NOT NULL default '0', - `unbandate` bigint(40) NOT NULL default '0', + `id` int(11) NOT NULL DEFAULT '0' COMMENT 'Account id', + `bandate` bigint(40) NOT NULL DEFAULT '0', + `unbandate` bigint(40) NOT NULL DEFAULT '0', `bannedby` varchar(50) NOT NULL, `banreason` varchar(255) NOT NULL, - `active` tinyint(4) NOT NULL default '1', - PRIMARY KEY (`id`,`bandate`) + `active` tinyint(4) NOT NULL DEFAULT '1', + PRIMARY KEY (`id`,`bandate`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Ban List'; /*!40101 SET character_set_client = @saved_cs_client */; @@ -113,12 +114,12 @@ DROP TABLE IF EXISTS `ip_banned`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `ip_banned` ( - `ip` varchar(32) NOT NULL default '127.0.0.1', + `ip` varchar(32) NOT NULL DEFAULT '127.0.0.1', `bandate` bigint(40) NOT NULL, `unbandate` bigint(40) NOT NULL, - `bannedby` varchar(50) NOT NULL default '[Console]', - `banreason` varchar(255) NOT NULL default 'no reason', - PRIMARY KEY (`ip`,`bandate`) + `bannedby` varchar(50) NOT NULL DEFAULT '[Console]', + `banreason` varchar(255) NOT NULL DEFAULT 'no reason', + PRIMARY KEY (`ip`,`bandate`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Banned IPs'; /*!40101 SET character_set_client = @saved_cs_client */; @@ -163,11 +164,11 @@ DROP TABLE IF EXISTS `realmcharacters`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `realmcharacters` ( - `realmid` int(11) unsigned NOT NULL default '0', + `realmid` int(11) unsigned NOT NULL DEFAULT '0', `acctid` bigint(20) unsigned NOT NULL, - `numchars` tinyint(3) unsigned NOT NULL default '0', - PRIMARY KEY (`realmid`,`acctid`), - KEY (acctid) + `numchars` tinyint(3) unsigned NOT NULL DEFAULT '0', + PRIMARY KEY (`realmid`,`acctid`), + KEY `acctid` (`acctid`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Realm Character Tracker'; /*!40101 SET character_set_client = @saved_cs_client */; @@ -188,17 +189,17 @@ DROP TABLE IF EXISTS `realmlist`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `realmlist` ( - `id` int(11) unsigned NOT NULL auto_increment, - `name` varchar(32) NOT NULL default '', - `address` varchar(32) NOT NULL default '127.0.0.1', - `port` int(11) NOT NULL default '8085', - `icon` tinyint(3) unsigned NOT NULL default '0', - `color` tinyint(3) unsigned NOT NULL default '2', - `timezone` tinyint(3) unsigned NOT NULL default '0', - `allowedSecurityLevel` tinyint(3) unsigned NOT NULL default '0', - `population` float unsigned NOT NULL default '0', - `gamebuild` int(11) unsigned NOT NULL default '12340', - PRIMARY KEY (`id`), + `id` int(11) unsigned NOT NULL AUTO_INCREMENT, + `name` varchar(32) NOT NULL DEFAULT '', + `address` varchar(32) NOT NULL DEFAULT '127.0.0.1', + `port` int(11) NOT NULL DEFAULT '8085', + `icon` tinyint(3) unsigned NOT NULL DEFAULT '0', + `color` tinyint(3) unsigned NOT NULL DEFAULT '2', + `timezone` tinyint(3) unsigned NOT NULL DEFAULT '0', + `allowedSecurityLevel` tinyint(3) unsigned NOT NULL DEFAULT '0', + `population` float unsigned NOT NULL DEFAULT '0', + `gamebuild` int(11) unsigned NOT NULL DEFAULT '12340', + PRIMARY KEY (`id`), UNIQUE KEY `idx_name` (`name`) ) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Realm System'; /*!40101 SET character_set_client = @saved_cs_client */; @@ -209,8 +210,7 @@ CREATE TABLE `realmlist` ( LOCK TABLES `realmlist` WRITE; /*!40000 ALTER TABLE `realmlist` DISABLE KEYS */; -INSERT INTO `realmlist` (`id`,`name`,`address`,`port`,`icon`,`color`,`timezone`,`allowedSecurityLevel`,`population`,`gamebuild`) VALUES -(1,'Trinity','127.0.0.1',8085,1,0,1,0,0,12340); +INSERT INTO `realmlist` VALUES (1,'Trinity','127.0.0.1',8085,1,0,1,0,0,12340); /*!40000 ALTER TABLE `realmlist` ENABLE KEYS */; UNLOCK TABLES; @@ -223,12 +223,12 @@ DROP TABLE IF EXISTS `uptime`; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `uptime` ( `realmid` int(11) unsigned NOT NULL, - `starttime` bigint(20) unsigned NOT NULL default '0', - `startstring` varchar(64) NOT NULL default '', - `uptime` bigint(20) unsigned NOT NULL default '0', - `maxplayers` smallint(5) unsigned NOT NULL default '0', - `revision` VARCHAR(255) NOT NULL DEFAULT 'Trinitycore', - PRIMARY KEY (`realmid`,`starttime`) + `starttime` bigint(20) unsigned NOT NULL DEFAULT '0', + `startstring` varchar(64) NOT NULL DEFAULT '', + `uptime` bigint(20) unsigned NOT NULL DEFAULT '0', + `maxplayers` smallint(5) unsigned NOT NULL DEFAULT '0', + `revision` varchar(255) NOT NULL DEFAULT 'Trinitycore', + PRIMARY KEY (`realmid`,`starttime`) ) ENGINE=MyISAM DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='Uptime system'; /*!40101 SET character_set_client = @saved_cs_client */; @@ -250,6 +250,4 @@ UNLOCK TABLES; /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */; /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */; --- Dump completed on 2008-01-10 11:37:06 - --- Updated on 2010-01-29 23:21:45 GMT+1 +-- Dump completed on 2012-02-19 13:18:35 diff --git a/sql/base/characters_database.sql b/sql/base/characters_database.sql index f02ae80e4..c38dced90 100644 --- a/sql/base/characters_database.sql +++ b/sql/base/characters_database.sql @@ -1953,11 +1953,11 @@ DROP TABLE IF EXISTS `lfg_data`; /*!40101 SET @saved_cs_client = @@character_set_client */; /*!40101 SET character_set_client = utf8 */; CREATE TABLE `lfg_data` ( - `guid` INT(10) UNSIGNED NOT NULL DEFAULT '0' COMMENT 'Global Unique Identifier', - `dungeon` INT(10) UNSIGNED NOT NULL DEFAULT '0', - `state` TINYINT(3) UNSIGNED NOT NULL DEFAULT '0', + `guid` int(10) unsigned NOT NULL DEFAULT '0' COMMENT 'Global Unique Identifier', + `dungeon` int(10) unsigned NOT NULL DEFAULT '0', + `state` tinyint(3) unsigned NOT NULL DEFAULT '0', PRIMARY KEY (`guid`) -) ENGINE=INNODB DEFAULT CHARSET=utf8 COMMENT='LFG Data'; +) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='LFG Data'; /*!40101 SET character_set_client = @saved_cs_client */; -- @@ -2214,6 +2214,29 @@ LOCK TABLES `reserved_name` WRITE; /*!40000 ALTER TABLE `reserved_name` ENABLE KEYS */; UNLOCK TABLES; +-- +-- Table structure for table `warden_action` +-- + +DROP TABLE IF EXISTS `warden_action`; +/*!40101 SET @saved_cs_client = @@character_set_client */; +/*!40101 SET character_set_client = utf8 */; +CREATE TABLE `warden_action` ( + `wardenId` smallint(5) unsigned NOT NULL, + `action` tinyint(3) unsigned DEFAULT NULL, + PRIMARY KEY (`wardenId`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8; +/*!40101 SET character_set_client = @saved_cs_client */; + +-- +-- Dumping data for table `warden_action` +-- + +LOCK TABLES `warden_action` WRITE; +/*!40000 ALTER TABLE `warden_action` DISABLE KEYS */; +/*!40000 ALTER TABLE `warden_action` ENABLE KEYS */; +UNLOCK TABLES; + -- -- Table structure for table `worldstates` -- diff --git a/sql/updates/auth/2012_02_19_00_auth_account.sql b/sql/updates/auth/2012_02_19_00_auth_account.sql new file mode 100644 index 000000000..a5b48ede3 --- /dev/null +++ b/sql/updates/auth/2012_02_19_00_auth_account.sql @@ -0,0 +1,2 @@ +ALTER TABLE `account` + ADD COLUMN `os` VARCHAR(4) DEFAULT '' NOT NULL AFTER `locale`; diff --git a/sql/updates/characters/2012_02_19_00_characters_warden_action.sql b/sql/updates/characters/2012_02_19_00_characters_warden_action.sql new file mode 100644 index 000000000..6e317f510 --- /dev/null +++ b/sql/updates/characters/2012_02_19_00_characters_warden_action.sql @@ -0,0 +1,7 @@ +DROP TABLE IF EXISTS `warden_action`; + +CREATE TABLE `warden_action` ( + `wardenId` smallint(5) unsigned NOT NULL, + `action` tinyint(3) unsigned DEFAULT NULL, + PRIMARY KEY (`wardenId`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8 diff --git a/sql/updates/world/2012_02_15_08_world_sai.sql b/sql/updates/world/2012_02_15_08_world_sai.sql new file mode 100644 index 000000000..ef49ff484 --- /dev/null +++ b/sql/updates/world/2012_02_15_08_world_sai.sql @@ -0,0 +1,9 @@ +SET @Pinata := 34632; + +DELETE FROM `smart_scripts` WHERE `entryorguid`=@Pinata AND `source_type`=0; +INSERT INTO `smart_scripts` (`entryorguid`, `source_type`, `id`, `link`, `event_type`, `event_phase_mask`, `event_chance`, `event_flags`, `event_param1`, `event_param2`, `event_param3`, `event_param4`, `action_type`, `action_param1`, `action_param2`, `action_param3`, `action_param4`, `action_param5`, `action_param6`, `target_type`, `target_param1`, `target_param2`, `target_param3`, `target_x`, `target_y`, `target_z`, `target_o`, `comment`) VALUES +(@Pinata, 0, 0, 0, 6, 0, 100, 0, 0, 0, 0, 0, 11, 65788, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 'Ogre Pinata - On death cast Pile of Candy'), +(@Pinata, 0, 1, 0, 25, 0, 100, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 'Ogre Pinata - On reset set react state passive'); + +-- same faction of the GO that is spawned by spell 65788 (not sniffed) +UPDATE `creature_template` SET `faction_A`=7,`faction_H`=7,`exp`=0,`AIName`='SmartAI' WHERE `entry`=@Pinata; diff --git a/sql/updates/world/2012_02_15_09_world_spell_proc_event.sql b/sql/updates/world/2012_02_15_09_world_spell_proc_event.sql new file mode 100644 index 000000000..4811e5d66 --- /dev/null +++ b/sql/updates/world/2012_02_15_09_world_spell_proc_event.sql @@ -0,0 +1,6 @@ +-- Corrected proc of Misery +DELETE FROM `spell_proc_event` WHERE `entry` IN (33191, 33192, 33193); +INSERT INTO `spell_proc_event` VALUES +(33191, 0x00, 0x06, 0x00008000, 0x00000400, 0x00000040, 0x00000000, 0x00000000, 0, 0, 0), +(33192, 0x00, 0x06, 0x00008000, 0x00000400, 0x00000040, 0x00000000, 0x00000000, 0, 0, 0), +(33193, 0x00, 0x06, 0x00008000, 0x00000400, 0x00000040, 0x00000000, 0x00000000, 0, 0, 0); diff --git a/sql/updates/world/2012_02_16_00_world_conditions.sql b/sql/updates/world/2012_02_16_00_world_conditions.sql new file mode 100644 index 000000000..a01792ef8 --- /dev/null +++ b/sql/updates/world/2012_02_16_00_world_conditions.sql @@ -0,0 +1,12800 @@ +CREATE TABLE `temp_convert_spells` +( + `id` INT(11), + PRIMARY KEY (`id`) +); + +# spells with EffectImplicitTarget In (6,21, 25) + spells having Targets & 1115534 +# those spells are the ones which require explicit unit target to cast +INSERT INTO `temp_convert_spells` VALUES +(5), +(11), +(12), +(14), +(15), +(17), +(25), +(49), +(50), +(53), +(56), +(58), +(59), +(60), +(61), +(67), +(68), +(72), +(75), +(78), +(89), +(91), +(96), +(100), +(101), +(113), +(116), +(118), +(131), +(132), +(133), +(134), +(139), +(142), +(143), +(145), +(172), +(184), +(205), +(228), +(246), +(260), +(271), +(284), +(285), +(339), +(348), +(355), +(370), +(403), +(408), +(421), +(453), +(457), +(467), +(475), +(512), +(514), +(526), +(527), +(528), +(529), +(530), +(546), +(548), +(550), +(552), +(585), +(589), +(591), +(592), +(594), +(596), +(598), +(600), +(603), +(605), +(606), +(633), +(635), +(639), +(647), +(676), +(686), +(689), +(692), +(694), +(695), +(699), +(700), +(701), +(702), +(703), +(705), +(707), +(709), +(710), +(720), +(731), +(744), +(745), +(746), +(770), +(772), +(774), +(782), +(785), +(812), +(835), +(837), +(845), +(851), +(853), +(879), +(915), +(921), +(930), +(932), +(943), +(970), +(974), +(976), +(980), +(984), +(988), +(992), +(996), +(1004), +(1010), +(1014), +(1026), +(1035), +(1042), +(1044), +(1058), +(1062), +(1075), +(1079), +(1082), +(1088), +(1090), +(1094), +(1098), +(1106), +(1108), +(1120), +(1121), +(1126), +(1130), +(1139), +(1152), +(1159), +(1194), +(1196), +(1210), +(1214), +(1225), +(1228), +(1234), +(1241), +(1243), +(1244), +(1245), +(1249), +(1250), +(1251), +(1266), +(1267), +(1329), +(1330), +(1350), +(1364), +(1373), +(1413), +(1430), +(1446), +(1459), +(1460), +(1461), +(1462), +(1464), +(1467), +(1472), +(1473), +(1474), +(1475), +(1481), +(1485), +(1490), +(1495), +(1513), +(1515), +(1516), +(1536), +(1579), +(1588), +(1604), +(1608), +(1609), +(1650), +(1664), +(1665), +(1666), +(1669), +(1671), +(1672), +(1714), +(1715), +(1752), +(1753), +(1754), +(1755), +(1756), +(1757), +(1758), +(1759), +(1760), +(1766), +(1767), +(1768), +(1769), +(1770), +(1776), +(1777), +(1795), +(1796), +(1797), +(1798), +(1800), +(1809), +(1810), +(1811), +(1822), +(1823), +(1824), +(1831), +(1833), +(1852), +(1906), +(1908), +(1943), +(1950), +(1966), +(1978), +(1991), +(2000), +(2020), +(2021), +(2050), +(2052), +(2053), +(2054), +(2055), +(2060), +(2061), +(2070), +(2090), +(2091), +(2094), +(2096), +(2098), +(2110), +(2118), +(2119), +(2124), +(2125), +(2136), +(2137), +(2138), +(2139), +(2141), +(2142), +(2143), +(2147), +(2148), +(2154), +(2155), +(2275), +(2280), +(2313), +(2372), +(2373), +(2400), +(2425), +(2442), +(2443), +(2444), +(2446), +(2552), +(2589), +(2590), +(2591), +(2601), +(2602), +(2606), +(2607), +(2608), +(2609), +(2610), +(2626), +(2629), +(2630), +(2633), +(2634), +(2636), +(2637), +(2643), +(2647), +(2649), +(2650), +(2653), +(2691), +(2764), +(2767), +(2782), +(2791), +(2800), +(2816), +(2817), +(2818), +(2819), +(2834), +(2850), +(2855), +(2860), +(2871), +(2880), +(2893), +(2908), +(2912), +(2941), +(2944), +(2948), +(2949), +(2969), +(2972), +(2973), +(2974), +(2995), +(3007), +(3009), +(3010), +(3011), +(3018), +(3029), +(3034), +(3043), +(3044), +(3105), +(3108), +(3110), +(3120), +(3121), +(3130), +(3131), +(3132), +(3137), +(3140), +(3145), +(3147), +(3148), +(3150), +(3205), +(3206), +(3207), +(3229), +(3233), +(3234), +(3237), +(3242), +(3243), +(3246), +(3247), +(3252), +(3261), +(3263), +(3267), +(3268), +(3279), +(3280), +(3286), +(3332), +(3355), +(3356), +(3358), +(3360), +(3387), +(3388), +(3393), +(3396), +(3405), +(3409), +(3427), +(3429), +(3436), +(3442), +(3446), +(3465), +(3466), +(3472), +(3510), +(3514), +(3539), +(3542), +(3551), +(3553), +(3571), +(3578), +(3583), +(3584), +(3586), +(3602), +(3603), +(3604), +(3606), +(3607), +(3609), +(3627), +(3635), +(3636), +(3650), +(3674), +(3715), +(3716), +(3747), +(3812), +(3911), +(3912), +(3913), +(3921), +(4011), +(4039), +(4040), +(4041), +(4058), +(4060), +(4089), +(4090), +(4091), +(4101), +(4102), +(4130), +(4131), +(4132), +(4150), +(4159), +(4164), +(4165), +(4166), +(4167), +(4168), +(4169), +(4209), +(4221), +(4240), +(4243), +(4244), +(4262), +(4280), +(4281), +(4282), +(4285), +(4286), +(4294), +(4316), +(4362), +(4423), +(4500), +(4504), +(4505), +(4506), +(4538), +(4630), +(4659), +(4805), +(4877), +(4940), +(4961), +(4962), +(4974), +(4979), +(4980), +(4984), +(4987), +(4996), +(4997), +(4998), +(4999), +(5000), +(5003), +(5019), +(5025), +(5103), +(5105), +(5116), +(5133), +(5137), +(5138), +(5143), +(5144), +(5145), +(5164), +(5165), +(5171), +(5176), +(5177), +(5178), +(5179), +(5180), +(5185), +(5186), +(5187), +(5188), +(5189), +(5195), +(5196), +(5201), +(5208), +(5211), +(5213), +(5221), +(5232), +(5234), +(5246), +(5255), +(5259), +(5260), +(5263), +(5271), +(5276), +(5306), +(5308), +(5320), +(5321), +(5322), +(5323), +(5324), +(5325), +(5337), +(5374), +(5375), +(5376), +(5401), +(5413), +(5416), +(5422), +(5424), +(5433), +(5480), +(5503), +(5507), +(5508), +(5509), +(5513), +(5514), +(5547), +(5565), +(5566), +(5567), +(5570), +(5588), +(5589), +(5595), +(5597), +(5598), +(5614), +(5615), +(5648), +(5649), +(5676), +(5679), +(5696), +(5697), +(5703), +(5726), +(5727), +(5739), +(5760), +(5781), +(5782), +(5862), +(5884), +(5917), +(5918), +(5938), +(5940), +(5951), +(5967), +(6000), +(6016), +(6027), +(6028), +(6041), +(6060), +(6061), +(6063), +(6064), +(6065), +(6066), +(6074), +(6075), +(6076), +(6077), +(6078), +(6121), +(6128), +(6130), +(6132), +(6136), +(6142), +(6144), +(6146), +(6178), +(6199), +(6203), +(6205), +(6213), +(6215), +(6217), +(6222), +(6223), +(6245), +(6252), +(6253), +(6254), +(6255), +(6257), +(6273), +(6277), +(6278), +(6304), +(6327), +(6346), +(6348), +(6349), +(6350), +(6351), +(6352), +(6353), +(6357), +(6358), +(6359), +(6360), +(6362), +(6409), +(6435), +(6460), +(6465), +(6466), +(6483), +(6484), +(6509), +(6530), +(6531), +(6533), +(6546), +(6547), +(6548), +(6552), +(6554), +(6555), +(6572), +(6574), +(6576), +(6580), +(6581), +(6595), +(6607), +(6647), +(6655), +(6660), +(6664), +(6685), +(6713), +(6716), +(6719), +(6726), +(6728), +(6730), +(6742), +(6743), +(6744), +(6745), +(6746), +(6747), +(6748), +(6751), +(6753), +(6754), +(6756), +(6760), +(6761), +(6762), +(6766), +(6767), +(6768), +(6770), +(6774), +(6778), +(6780), +(6785), +(6787), +(6788), +(6789), +(6795), +(6798), +(6800), +(6807), +(6808), +(6809), +(6814), +(6866), +(6870), +(6873), +(6894), +(6907), +(6909), +(6917), +(6922), +(6927), +(6942), +(6946), +(6949), +(6950), +(6951), +(6957), +(6958), +(6960), +(6963), +(6965), +(6979), +(6980), +(6984), +(7001), +(7033), +(7054), +(7057), +(7068), +(7079), +(7081), +(7084), +(7092), +(7093), +(7098), +(7099), +(7101), +(7102), +(7105), +(7120), +(7122), +(7124), +(7125), +(7127), +(7140), +(7145), +(7154), +(7159), +(7160), +(7162), +(7211), +(7266), +(7288), +(7289), +(7290), +(7295), +(7321), +(7322), +(7329), +(7357), +(7365), +(7367), +(7369), +(7372), +(7373), +(7379), +(7384), +(7386), +(7399), +(7400), +(7402), +(7405), +(7414), +(7415), +(7416), +(7439), +(7482), +(7485), +(7588), +(7621), +(7638), +(7641), +(7645), +(7646), +(7648), +(7651), +(7655), +(7656), +(7712), +(7714), +(7715), +(7716), +(7717), +(7718), +(7719), +(7736), +(7761), +(7763), +(7764), +(7799), +(7800), +(7801), +(7802), +(7806), +(7807), +(7808), +(7809), +(7810), +(7811), +(7813), +(7814), +(7815), +(7816), +(7821), +(7829), +(7853), +(7874), +(7875), +(7876), +(7877), +(7878), +(7879), +(7880), +(7881), +(7882), +(7883), +(7884), +(7885), +(7887), +(7891), +(7896), +(7901), +(7914), +(7922), +(7925), +(7926), +(7927), +(7932), +(7933), +(7938), +(7947), +(7951), +(7967), +(7992), +(7994), +(7997), +(8004), +(8008), +(8010), +(8012), +(8014), +(8016), +(8026), +(8028), +(8029), +(8034), +(8037), +(8040), +(8042), +(8044), +(8045), +(8046), +(8050), +(8052), +(8053), +(8056), +(8058), +(8068), +(8070), +(8091), +(8092), +(8094), +(8095), +(8096), +(8097), +(8098), +(8099), +(8100), +(8101), +(8102), +(8103), +(8104), +(8105), +(8106), +(8112), +(8113), +(8114), +(8115), +(8116), +(8117), +(8118), +(8119), +(8120), +(8121), +(8129), +(8137), +(8138), +(8139), +(8140), +(8151), +(8208), +(8211), +(8221), +(8222), +(8242), +(8246), +(8255), +(8256), +(8257), +(8272), +(8275), +(8277), +(8282), +(8288), +(8289), +(8292), +(8295), +(8312), +(8313), +(8314), +(8318), +(8319), +(8344), +(8345), +(8346), +(8347), +(8352), +(8353), +(8355), +(8362), +(8363), +(8365), +(8379), +(8380), +(8382), +(8383), +(8384), +(8385), +(8391), +(8400), +(8401), +(8402), +(8406), +(8407), +(8408), +(8412), +(8413), +(8414), +(8415), +(8416), +(8417), +(8425), +(8426), +(8428), +(8440), +(8441), +(8442), +(8444), +(8445), +(8446), +(8447), +(8448), +(8449), +(8452), +(8453), +(8456), +(8459), +(8460), +(8463), +(8464), +(8493), +(8496), +(8497), +(8552), +(8554), +(8555), +(8595), +(8598), +(8600), +(8613), +(8615), +(8616), +(8617), +(8618), +(8619), +(8620), +(8621), +(8623), +(8624), +(8627), +(8629), +(8631), +(8632), +(8633), +(8637), +(8639), +(8640), +(8643), +(8645), +(8646), +(8647), +(8649), +(8650), +(8654), +(8673), +(8676), +(8680), +(8682), +(8685), +(8689), +(8699), +(8716), +(8721), +(8724), +(8725), +(8733), +(8735), +(8788), +(8806), +(8818), +(8820), +(8903), +(8905), +(8907), +(8910), +(8914), +(8921), +(8924), +(8925), +(8926), +(8927), +(8928), +(8929), +(8936), +(8938), +(8939), +(8940), +(8941), +(8946), +(8947), +(8949), +(8950), +(8951), +(8955), +(8972), +(8983), +(8992), +(8994), +(8998), +(9000), +(9005), +(9007), +(9034), +(9053), +(9057), +(9080), +(9159), +(9176), +(9234), +(9268), +(9275), +(9347), +(9373), +(9454), +(9455), +(9456), +(9459), +(9462), +(9472), +(9473), +(9474), +(9481), +(9482), +(9483), +(9484), +(9485), +(9487), +(9488), +(9492), +(9493), +(9532), +(9552), +(9574), +(9591), +(9612), +(9613), +(9614), +(9654), +(9658), +(9672), +(9734), +(9735), +(9739), +(9745), +(9750), +(9752), +(9756), +(9758), +(9771), +(9775), +(9786), +(9789), +(9790), +(9791), +(9796), +(9806), +(9823), +(9824), +(9826), +(9827), +(9829), +(9830), +(9833), +(9834), +(9835), +(9839), +(9840), +(9841), +(9849), +(9850), +(9852), +(9853), +(9856), +(9857), +(9858), +(9866), +(9867), +(9875), +(9876), +(9880), +(9881), +(9884), +(9885), +(9888), +(9889), +(9892), +(9894), +(9896), +(9901), +(9904), +(9910), +(9912), +(9949), +(9977), +(9991), +(9999), +(10055), +(10056), +(10060), +(10073), +(10101), +(10136), +(10141), +(10142), +(10143), +(10146), +(10147), +(10148), +(10149), +(10150), +(10151), +(10156), +(10157), +(10158), +(10162), +(10163), +(10164), +(10171), +(10172), +(10175), +(10176), +(10178), +(10179), +(10180), +(10181), +(10188), +(10189), +(10190), +(10194), +(10195), +(10196), +(10197), +(10198), +(10199), +(10200), +(10203), +(10204), +(10205), +(10206), +(10207), +(10208), +(10209), +(10210), +(10211), +(10212), +(10217), +(10218), +(10221), +(10222), +(10224), +(10226), +(10227), +(10231), +(10239), +(10244), +(10245), +(10246), +(10277), +(10308), +(10310), +(10312), +(10313), +(10314), +(10321), +(10326), +(10328), +(10329), +(10346), +(10370), +(10371), +(10373), +(10391), +(10392), +(10412), +(10413), +(10414), +(10435), +(10436), +(10444), +(10445), +(10447), +(10448), +(10452), +(10458), +(10466), +(10467), +(10468), +(10472), +(10473), +(10577), +(10578), +(10605), +(10617), +(10651), +(10653), +(10657), +(10659), +(10661), +(10663), +(10689), +(10730), +(10767), +(10768), +(10769), +(10771), +(10833), +(10838), +(10839), +(10843), +(10847), +(10851), +(10855), +(10863), +(10872), +(10892), +(10893), +(10894), +(10898), +(10899), +(10900), +(10901), +(10908), +(10909), +(10915), +(10916), +(10917), +(10921), +(10927), +(10928), +(10929), +(10933), +(10934), +(10937), +(10938), +(10945), +(10946), +(10947), +(10955), +(10957), +(10958), +(10960), +(10961), +(10963), +(10964), +(10965), +(10966), +(11014), +(11016), +(11020), +(11021), +(11027), +(11084), +(11085), +(11131), +(11132), +(11196), +(11197), +(11198), +(11203), +(11204), +(11205), +(11267), +(11268), +(11269), +(11273), +(11274), +(11275), +(11279), +(11280), +(11281), +(11285), +(11286), +(11289), +(11290), +(11293), +(11294), +(11297), +(11299), +(11300), +(11303), +(11335), +(11336), +(11337), +(11353), +(11354), +(11362), +(11366), +(11374), +(11391), +(11397), +(11409), +(11428), +(11430), +(11431), +(11436), +(11442), +(11443), +(11444), +(11446), +(11469), +(11470), +(11471), +(11512), +(11519), +(11520), +(11522), +(11525), +(11528), +(11538), +(11539), +(11545), +(11564), +(11565), +(11566), +(11567), +(11572), +(11573), +(11574), +(11578), +(11584), +(11585), +(11595), +(11596), +(11597), +(11600), +(11601), +(11604), +(11605), +(11608), +(11609), +(11610), +(11612), +(11639), +(11640), +(11641), +(11642), +(11650), +(11658), +(11659), +(11660), +(11661), +(11665), +(11667), +(11668), +(11671), +(11672), +(11675), +(11699), +(11700), +(11707), +(11708), +(11711), +(11712), +(11713), +(11719), +(11721), +(11722), +(11725), +(11726), +(11762), +(11763), +(11772), +(11773), +(11774), +(11775), +(11776), +(11777), +(11778), +(11779), +(11780), +(11781), +(11782), +(11783), +(11784), +(11785), +(11786), +(11787), +(11791), +(11820), +(11821), +(11824), +(11825), +(11835), +(11836), +(11839), +(11877), +(11879), +(11885), +(11886), +(11887), +(11888), +(11889), +(11918), +(11920), +(11921), +(11922), +(11960), +(11962), +(11963), +(11971), +(11972), +(11974), +(11976), +(11977), +(11978), +(11980), +(11981), +(11985), +(11986), +(11994), +(11998), +(12021), +(12023), +(12024), +(12039), +(12054), +(12057), +(12058), +(12096), +(12097), +(12098), +(12118), +(12127), +(12128), +(12130), +(12131), +(12160), +(12161), +(12162), +(12166), +(12167), +(12170), +(12174), +(12175), +(12176), +(12177), +(12178), +(12179), +(12181), +(12242), +(12245), +(12246), +(12248), +(12251), +(12279), +(12280), +(12289), +(12294), +(12355), +(12461), +(12466), +(12471), +(12479), +(12480), +(12484), +(12485), +(12486), +(12491), +(12492), +(12493), +(12494), +(12505), +(12509), +(12510), +(12521), +(12522), +(12523), +(12524), +(12525), +(12526), +(12531), +(12538), +(12540), +(12541), +(12542), +(12545), +(12548), +(12551), +(12553), +(12555), +(12578), +(12579), +(12654), +(12657), +(12668), +(12675), +(12693), +(12699), +(12705), +(12721), +(12723), +(12738), +(12739), +(12742), +(12747), +(12798), +(12809), +(12821), +(12824), +(12825), +(12826), +(12850), +(12868), +(12885), +(12888), +(12890), +(12998), +(13003), +(13005), +(13006), +(13009), +(13013), +(13022), +(13029), +(13044), +(13099), +(13119), +(13120), +(13138), +(13140), +(13142), +(13180), +(13181), +(13218), +(13222), +(13223), +(13224), +(13278), +(13279), +(13281), +(13298), +(13318), +(13319), +(13321), +(13322), +(13323), +(13325), +(13326), +(13327), +(13338), +(13339), +(13340), +(13341), +(13342), +(13374), +(13375), +(13398), +(13424), +(13438), +(13439), +(13440), +(13441), +(13442), +(13443), +(13444), +(13445), +(13446), +(13459), +(13480), +(13482), +(13486), +(13490), +(13491), +(13496), +(13518), +(13519), +(13524), +(13526), +(13527), +(13528), +(13530), +(13534), +(13549), +(13550), +(13551), +(13552), +(13553), +(13554), +(13555), +(13566), +(13567), +(13579), +(13583), +(13584), +(13585), +(13608), +(13619), +(13692), +(13728), +(13729), +(13737), +(13738), +(13748), +(13752), +(13797), +(13860), +(13864), +(13878), +(13880), +(13884), +(13897), +(13901), +(13902), +(13907), +(13921), +(13952), +(13953), +(13977), +(14030), +(14032), +(14033), +(14034), +(14053), +(14087), +(14099), +(14102), +(14103), +(14105), +(14106), +(14109), +(14110), +(14112), +(14118), +(14119), +(14120), +(14122), +(14126), +(14129), +(14130), +(14134), +(14145), +(14156), +(14157), +(14160), +(14178), +(14180), +(14183), +(14189), +(14200), +(14247), +(14251), +(14253), +(14260), +(14261), +(14262), +(14263), +(14264), +(14265), +(14266), +(14269), +(14270), +(14271), +(14278), +(14281), +(14282), +(14283), +(14284), +(14285), +(14286), +(14287), +(14288), +(14289), +(14290), +(14298), +(14299), +(14300), +(14301), +(14308), +(14309), +(14323), +(14324), +(14325), +(14326), +(14327), +(14331), +(14443), +(14515), +(14516), +(14517), +(14518), +(14537), +(14752), +(14792), +(14795), +(14818), +(14819), +(14867), +(14868), +(14873), +(14874), +(14875), +(14890), +(14892), +(14893), +(14894), +(14895), +(14897), +(14902), +(14903), +(14914), +(14916), +(14917), +(14918), +(14919), +(14920), +(14921), +(15037), +(15039), +(15040), +(15042), +(15043), +(15057), +(15065), +(15089), +(15090), +(15095), +(15096), +(15117), +(15120), +(15122), +(15123), +(15124), +(15128), +(15187), +(15207), +(15208), +(15211), +(15228), +(15229), +(15230), +(15232), +(15234), +(15235), +(15236), +(15238), +(15241), +(15242), +(15247), +(15248), +(15249), +(15250), +(15254), +(15257), +(15261), +(15262), +(15263), +(15264), +(15265), +(15266), +(15267), +(15277), +(15279), +(15280), +(15283), +(15284), +(15288), +(15305), +(15306), +(15331), +(15332), +(15342), +(15343), +(15344), +(15346), +(15357), +(15359), +(15362), +(15363), +(15366), +(15398), +(15407), +(15451), +(15471), +(15472), +(15487), +(15493), +(15495), +(15496), +(15497), +(15498), +(15499), +(15500), +(15501), +(15505), +(15530), +(15534), +(15535), +(15536), +(15537), +(15539), +(15547), +(15549), +(15570), +(15572), +(15574), +(15575), +(15580), +(15581), +(15582), +(15583), +(15586), +(15587), +(15592), +(15598), +(15605), +(15607), +(15608), +(15610), +(15611), +(15612), +(15614), +(15615), +(15616), +(15617), +(15618), +(15619), +(15620), +(15621), +(15643), +(15651), +(15652), +(15653), +(15654), +(15655), +(15656), +(15657), +(15659), +(15661), +(15662), +(15664), +(15665), +(15667), +(15691), +(15692), +(15695), +(15698), +(15699), +(15702), +(15708), +(15712), +(15713), +(15729), +(15730), +(15732), +(15734), +(15735), +(15736), +(15749), +(15752), +(15753), +(15784), +(15785), +(15790), +(15791), +(15793), +(15795), +(15797), +(15798), +(15801), +(15802), +(15848), +(15850), +(15859), +(15860), +(15876), +(15878), +(15968), +(15969), +(15970), +(15976), +(15980), +(15981), +(15982), +(16000), +(16001), +(16006), +(16007), +(16029), +(16031), +(16033), +(16034), +(16044), +(16045), +(16050), +(16053), +(16067), +(16071), +(16075), +(16095), +(16100), +(16101), +(16128), +(16143), +(16144), +(16145), +(16168), +(16170), +(16172), +(16176), +(16177), +(16186), +(16231), +(16235), +(16236), +(16237), +(16240), +(16243), +(16247), +(16249), +(16333), +(16336), +(16343), +(16344), +(16351), +(16352), +(16353), +(16366), +(16373), +(16375), +(16391), +(16392), +(16393), +(16400), +(16401), +(16402), +(16403), +(16405), +(16406), +(16407), +(16408), +(16409), +(16410), +(16411), +(16412), +(16413), +(16414), +(16415), +(16427), +(16429), +(16430), +(16431), +(16433), +(16448), +(16449), +(16451), +(16454), +(16455), +(16456), +(16458), +(16460), +(16461), +(16472), +(16495), +(16496), +(16498), +(16508), +(16509), +(16511), +(16527), +(16528), +(16530), +(16536), +(16549), +(16552), +(16553), +(16554), +(16555), +(16561), +(16564), +(16565), +(16568), +(16569), +(16570), +(16573), +(16583), +(16587), +(16588), +(16603), +(16608), +(16610), +(16612), +(16614), +(16618), +(16627), +(16628), +(16636), +(16697), +(16707), +(16708), +(16709), +(16711), +(16712), +(16713), +(16714), +(16716), +(16722), +(16782), +(16783), +(16784), +(16788), +(16790), +(16793), +(16798), +(16799), +(16804), +(16805), +(16827), +(16828), +(16829), +(16830), +(16831), +(16832), +(16844), +(16856), +(16857), +(16868), +(16869), +(16871), +(16898), +(16908), +(16921), +(16922), +(16927), +(16928), +(16953), +(16979), +(16997), +(17008), +(17009), +(17011), +(17012), +(17013), +(17105), +(17134), +(17137), +(17138), +(17139), +(17140), +(17141), +(17142), +(17143), +(17144), +(17146), +(17147), +(17148), +(17149), +(17150), +(17151), +(17153), +(17156), +(17157), +(17158), +(17159), +(17160), +(17165), +(17168), +(17170), +(17171), +(17172), +(17173), +(17174), +(17175), +(17183), +(17194), +(17195), +(17198), +(17201), +(17213), +(17227), +(17230), +(17233), +(17234), +(17238), +(17243), +(17244), +(17246), +(17253), +(17255), +(17256), +(17257), +(17258), +(17259), +(17260), +(17261), +(17273), +(17274), +(17276), +(17281), +(17284), +(17287), +(17289), +(17290), +(17292), +(17293), +(17307), +(17308), +(17311), +(17312), +(17313), +(17314), +(17315), +(17330), +(17331), +(17333), +(17334), +(17347), +(17348), +(17353), +(17364), +(17368), +(17393), +(17405), +(17407), +(17434), +(17435), +(17439), +(17445), +(17451), +(17452), +(17470), +(17483), +(17484), +(17492), +(17494), +(17496), +(17500), +(17503), +(17504), +(17505), +(17506), +(17509), +(17510), +(17511), +(17529), +(17547), +(17607), +(17608), +(17609), +(17610), +(17611), +(17613), +(17615), +(17620), +(17630), +(17633), +(17639), +(17648), +(17649), +(17672), +(17682), +(17692), +(17734), +(17736), +(17738), +(17744), +(17745), +(17749), +(17753), +(17754), +(17755), +(17776), +(17777), +(17794), +(17797), +(17798), +(17799), +(17800), +(17843), +(17855), +(17856), +(17857), +(17859), +(17860), +(17863), +(17877), +(17883), +(17919), +(17920), +(17921), +(17922), +(17923), +(17924), +(17925), +(17926), +(17939), +(17943), +(17944), +(17946), +(17948), +(17950), +(17961), +(17962), +(17963), +(18070), +(18072), +(18075), +(18077), +(18078), +(18081), +(18082), +(18083), +(18084), +(18085), +(18086), +(18088), +(18089), +(18090), +(18091), +(18092), +(18101), +(18103), +(18104), +(18105), +(18106), +(18107), +(18108), +(18111), +(18112), +(18118), +(18138), +(18145), +(18149), +(18151), +(18152), +(18153), +(18159), +(18164), +(18165), +(18172), +(18173), +(18187), +(18197), +(18199), +(18200), +(18202), +(18203), +(18204), +(18205), +(18206), +(18208), +(18209), +(18210), +(18211), +(18214), +(18217), +(18223), +(18266), +(18267), +(18270), +(18276), +(18278), +(18289), +(18347), +(18362), +(18367), +(18368), +(18375), +(18381), +(18387), +(18389), +(18390), +(18395), +(18396), +(18398), +(18425), +(18469), +(18476), +(18498), +(18502), +(18503), +(18543), +(18545), +(18557), +(18561), +(18562), +(18608), +(18610), +(18631), +(18632), +(18633), +(18647), +(18649), +(18651), +(18652), +(18654), +(18656), +(18657), +(18658), +(18663), +(18670), +(18702), +(18761), +(18763), +(18796), +(18798), +(18802), +(18805), +(18807), +(18809), +(18812), +(18813), +(18817), +(18819), +(18833), +(18867), +(18868), +(18869), +(18870), +(18871), +(18945), +(18952), +(18958), +(18968), +(18972), +(18980), +(18988), +(18996), +(19027), +(19128), +(19130), +(19131), +(19132), +(19133), +(19134), +(19136), +(19179), +(19196), +(19213), +(19244), +(19260), +(19276), +(19277), +(19278), +(19279), +(19280), +(19306), +(19319), +(19362), +(19386), +(19391), +(19393), +(19395), +(19397), +(19411), +(19434), +(19437), +(19439), +(19444), +(19445), +(19446), +(19447), +(19448), +(19450), +(19452), +(19460), +(19463), +(19469), +(19471), +(19472), +(19476), +(19481), +(19486), +(19501), +(19503), +(19505), +(19512), +(19548), +(19595), +(19597), +(19632), +(19633), +(19637), +(19639), +(19642), +(19643), +(19644), +(19647), +(19648), +(19650), +(19652), +(19653), +(19654), +(19658), +(19661), +(19662), +(19663), +(19664), +(19674), +(19675), +(19676), +(19677), +(19678), +(19679), +(19680), +(19681), +(19682), +(19683), +(19684), +(19685), +(19686), +(19687), +(19688), +(19689), +(19692), +(19693), +(19694), +(19696), +(19697), +(19699), +(19700), +(19701), +(19725), +(19727), +(19728), +(19729), +(19730), +(19731), +(19734), +(19736), +(19737), +(19738), +(19739), +(19740), +(19742), +(19750), +(19755), +(19767), +(19770), +(19771), +(19775), +(19776), +(19777), +(19779), +(19785), +(19797), +(19801), +(19816), +(19820), +(19834), +(19835), +(19836), +(19837), +(19838), +(19850), +(19852), +(19853), +(19854), +(19869), +(19872), +(19874), +(19881), +(19901), +(19931), +(19938), +(19939), +(19940), +(19941), +(19942), +(19943), +(19970), +(19971), +(19972), +(19973), +(19974), +(19975), +(19983), +(20000), +(20004), +(20005), +(20006), +(20019), +(20066), +(20170), +(20184), +(20185), +(20186), +(20187), +(20211), +(20217), +(20220), +(20221), +(20223), +(20228), +(20233), +(20236), +(20240), +(20243), +(20252), +(20253), +(20271), +(20276), +(20279), +(20294), +(20295), +(20297), +(20298), +(20367), +(20368), +(20369), +(20370), +(20371), +(20372), +(20373), +(20374), +(20410), +(20420), +(20424), +(20425), +(20463), +(20467), +(20473), +(20474), +(20475), +(20477), +(20508), +(20511), +(20534), +(20535), +(20536), +(20537), +(20539), +(20541), +(20543), +(20547), +(20559), +(20560), +(20564), +(20565), +(20569), +(20586), +(20604), +(20605), +(20614), +(20615), +(20616), +(20617), +(20618), +(20623), +(20625), +(20627), +(20629), +(20630), +(20647), +(20655), +(20656), +(20657), +(20658), +(20660), +(20661), +(20662), +(20663), +(20664), +(20665), +(20666), +(20668), +(20677), +(20678), +(20679), +(20682), +(20684), +(20685), +(20688), +(20690), +(20691), +(20692), +(20695), +(20696), +(20698), +(20700), +(20714), +(20720), +(20726), +(20733), +(20735), +(20736), +(20740), +(20751), +(20787), +(20788), +(20790), +(20791), +(20792), +(20793), +(20795), +(20797), +(20800), +(20801), +(20802), +(20804), +(20805), +(20806), +(20807), +(20808), +(20811), +(20812), +(20815), +(20816), +(20819), +(20820), +(20821), +(20822), +(20823), +(20824), +(20825), +(20826), +(20829), +(20830), +(20831), +(20832), +(20869), +(20882), +(20883), +(20893), +(20900), +(20901), +(20902), +(20903), +(20904), +(20909), +(20910), +(20911), +(20929), +(20930), +(20989), +(21008), +(21027), +(21030), +(21047), +(21049), +(21050), +(21055), +(21056), +(21059), +(21060), +(21062), +(21063), +(21064), +(21066), +(21067), +(21068), +(21072), +(21074), +(21077), +(21081), +(21100), +(21128), +(21140), +(21141), +(21150), +(21151), +(21159), +(21162), +(21163), +(21164), +(21170), +(21179), +(21183), +(21187), +(21330), +(21332), +(21335), +(21337), +(21343), +(21356), +(21357), +(21368), +(21369), +(21372), +(21388), +(21390), +(21398), +(21401), +(21402), +(21463), +(21464), +(21465), +(21541), +(21542), +(21543), +(21546), +(21549), +(21551), +(21552), +(21553), +(21647), +(21654), +(21667), +(21668), +(21669), +(21670), +(21731), +(21732), +(21734), +(21735), +(21737), +(21745), +(21787), +(21794), +(21807), +(21829), +(21832), +(21834), +(21835), +(21840), +(21847), +(21866), +(21889), +(21892), +(21898), +(21912), +(21939), +(21949), +(21952), +(21953), +(21960), +(21961), +(21971), +(21979), +(21987), +(21990), +(21992), +(22009), +(22012), +(22048), +(22068), +(22088), +(22108), +(22109), +(22110), +(22111), +(22112), +(22113), +(22114), +(22115), +(22116), +(22117), +(22118), +(22119), +(22120), +(22121), +(22127), +(22128), +(22167), +(22168), +(22187), +(22189), +(22207), +(22227), +(22272), +(22273), +(22274), +(22284), +(22289), +(22290), +(22291), +(22312), +(22335), +(22336), +(22355), +(22357), +(22371), +(22373), +(22411), +(22412), +(22414), +(22415), +(22416), +(22418), +(22423), +(22426), +(22427), +(22428), +(22429), +(22433), +(22438), +(22482), +(22565), +(22568), +(22570), +(22572), +(22574), +(22575), +(22582), +(22591), +(22592), +(22639), +(22641), +(22646), +(22651), +(22661), +(22662), +(22666), +(22667), +(22677), +(22678), +(22682), +(22687), +(22689), +(22690), +(22691), +(22692), +(22695), +(22709), +(22713), +(22715), +(22742), +(22744), +(22745), +(22751), +(22752), +(22784), +(22785), +(22799), +(22800), +(22814), +(22816), +(22817), +(22818), +(22820), +(22822), +(22823), +(22827), +(22828), +(22829), +(22856), +(22858), +(22859), +(22864), +(22883), +(22885), +(22886), +(22887), +(22893), +(22901), +(22907), +(22909), +(22911), +(22916), +(22919), +(22920), +(22935), +(22947), +(22950), +(22951), +(22959), +(22968), +(22993), +(22994), +(22995), +(22997), +(23015), +(23038), +(23059), +(23064), +(23065), +(23073), +(23102), +(23104), +(23106), +(23114), +(23115), +(23122), +(23123), +(23124), +(23125), +(23135), +(23139), +(23153), +(23154), +(23155), +(23169), +(23170), +(23174), +(23205), +(23206), +(23224), +(23256), +(23262), +(23267), +(23268), +(23275), +(23278), +(23298), +(23301), +(23304), +(23333), +(23335), +(23337), +(23340), +(23359), +(23379), +(23380), +(23381), +(23391), +(23392), +(23402), +(23416), +(23417), +(23451), +(23452), +(23454), +(23460), +(23490), +(23491), +(23493), +(23504), +(23505), +(23546), +(23552), +(23567), +(23568), +(23569), +(23577), +(23580), +(23590), +(23592), +(23601), +(23604), +(23605), +(23620), +(23621), +(23622), +(23623), +(23625), +(23626), +(23627), +(23658), +(23661), +(23675), +(23687), +(23693), +(23694), +(23695), +(23696), +(23699), +(23702), +(23735), +(23736), +(23737), +(23738), +(23765), +(23766), +(23767), +(23768), +(23769), +(23774), +(23775), +(23786), +(23848), +(23850), +(23853), +(23859), +(23860), +(23862), +(23865), +(23881), +(23892), +(23893), +(23894), +(23895), +(23921), +(23922), +(23923), +(23924), +(23925), +(23947), +(23948), +(23952), +(23953), +(23958), +(23959), +(23960), +(23961), +(23962), +(23963), +(23964), +(23967), +(23970), +(23978), +(23979), +(24002), +(24003), +(24016), +(24017), +(24020), +(24023), +(24042), +(24049), +(24053), +(24061), +(24064), +(24097), +(24109), +(24111), +(24131), +(24132), +(24133), +(24134), +(24135), +(24178), +(24179), +(24185), +(24187), +(24193), +(24199), +(24201), +(24208), +(24210), +(24212), +(24213), +(24238), +(24239), +(24241), +(24248), +(24251), +(24253), +(24254), +(24257), +(24259), +(24261), +(24267), +(24274), +(24275), +(24300), +(24306), +(24314), +(24315), +(24316), +(24317), +(24327), +(24331), +(24332), +(24333), +(24335), +(24336), +(24337), +(24339), +(24341), +(24374), +(24378), +(24379), +(24388), +(24393), +(24394), +(24407), +(24408), +(24412), +(24413), +(24414), +(24423), +(24435), +(24458), +(24466), +(24530), +(24573), +(24577), +(24578), +(24579), +(24583), +(24585), +(24586), +(24587), +(24596), +(24600), +(24601), +(24611), +(24617), +(24618), +(24619), +(24637), +(24640), +(24648), +(24649), +(24668), +(24671), +(24672), +(24674), +(24680), +(24684), +(24685), +(24686), +(24690), +(24705), +(24708), +(24709), +(24710), +(24711), +(24712), +(24713), +(24714), +(24715), +(24723), +(24725), +(24726), +(24727), +(24730), +(24732), +(24735), +(24736), +(24740), +(24742), +(24745), +(24747), +(24750), +(24751), +(24752), +(24753), +(24755), +(24757), +(24759), +(24761), +(24762), +(24766), +(24767), +(24769), +(24771), +(24773), +(24776), +(24785), +(24787), +(24791), +(24792), +(24793), +(24802), +(24803), +(24816), +(24817), +(24819), +(24824), +(24825), +(24826), +(24829), +(24831), +(24832), +(24844), +(24857), +(24872), +(24873), +(24875), +(24923), +(24928), +(24935), +(24937), +(24942), +(24950), +(24951), +(24952), +(24953), +(24954), +(24955), +(24957), +(24960), +(24961), +(24962), +(24963), +(24964), +(24965), +(24966), +(24974), +(24975), +(24976), +(24977), +(24982), +(24993), +(25006), +(25008), +(25009), +(25010), +(25011), +(25012), +(25021), +(25022), +(25025), +(25028), +(25050), +(25051), +(25052), +(25054), +(25055), +(25058), +(25104), +(25139), +(25140), +(25143), +(25165), +(25174), +(25185), +(25187), +(25189), +(25190), +(25191), +(25208), +(25210), +(25212), +(25213), +(25217), +(25218), +(25221), +(25222), +(25225), +(25231), +(25233), +(25234), +(25235), +(25236), +(25241), +(25242), +(25245), +(25246), +(25248), +(25251), +(25258), +(25262), +(25263), +(25266), +(25269), +(25272), +(25273), +(25274), +(25275), +(25281), +(25282), +(25286), +(25288), +(25290), +(25291), +(25292), +(25294), +(25295), +(25297), +(25298), +(25299), +(25300), +(25302), +(25304), +(25306), +(25307), +(25308), +(25309), +(25311), +(25312), +(25314), +(25315), +(25316), +(25345), +(25349), +(25363), +(25364), +(25367), +(25368), +(25371), +(25372), +(25373), +(25375), +(25383), +(25384), +(25387), +(25389), +(25391), +(25396), +(25420), +(25424), +(25433), +(25439), +(25442), +(25448), +(25449), +(25454), +(25457), +(25462), +(25464), +(25465), +(25467), +(25471), +(25488), +(25497), +(25501), +(25504), +(25514), +(25515), +(25530), +(25531), +(25595), +(25602), +(25603), +(25605), +(25645), +(25646), +(25650), +(25651), +(25652), +(25668), +(25671), +(25673), +(25677), +(25678), +(25686), +(25710), +(25712), +(25721), +(25725), +(25742), +(25748), +(25755), +(25760), +(25761), +(25762), +(25771), +(25772), +(25777), +(25778), +(25779), +(25781), +(25788), +(25800), +(25802), +(25803), +(25806), +(25807), +(25808), +(25809), +(25810), +(25811), +(25816), +(25821), +(25838), +(25840), +(25843), +(25845), +(25847), +(25848), +(25852), +(25854), +(25856), +(25861), +(25902), +(25903), +(25911), +(25912), +(25913), +(25914), +(25947), +(25992), +(25995), +(25997), +(25999), +(26001), +(26004), +(26005), +(26006), +(26007), +(26008), +(26012), +(26013), +(26017), +(26035), +(26044), +(26050), +(26077), +(26078), +(26079), +(26081), +(26082), +(26090), +(26095), +(26097), +(26098), +(26100), +(26108), +(26125), +(26126), +(26134), +(26141), +(26143), +(26170), +(26181), +(26194), +(26195), +(26196), +(26197), +(26198), +(26206), +(26207), +(26211), +(26218), +(26226), +(26233), +(26258), +(26259), +(26275), +(26281), +(26282), +(26339), +(26350), +(26363), +(26364), +(26365), +(26366), +(26367), +(26368), +(26369), +(26370), +(26371), +(26372), +(26374), +(26375), +(26377), +(26406), +(26408), +(26409), +(26410), +(26412), +(26414), +(26415), +(26419), +(26446), +(26448), +(26470), +(26476), +(26548), +(26556), +(26561), +(26565), +(26572), +(26584), +(26601), +(26610), +(26613), +(26616), +(26622), +(26623), +(26624), +(26625), +(26636), +(26639), +(26641), +(26649), +(26654), +(26663), +(26679), +(26688), +(26693), +(26740), +(26742), +(26748), +(26791), +(26796), +(26799), +(26800), +(26839), +(26861), +(26862), +(26863), +(26864), +(26865), +(26866), +(26867), +(26884), +(26890), +(26899), +(26923), +(26924), +(26968), +(26978), +(26979), +(26980), +(26981), +(26982), +(26984), +(26985), +(26986), +(26987), +(26988), +(26989), +(26990), +(26992), +(26995), +(26996), +(27000), +(27001), +(27002), +(27003), +(27004), +(27005), +(27006), +(27007), +(27008), +(27010), +(27013), +(27014), +(27016), +(27019), +(27021), +(27024), +(27030), +(27031), +(27047), +(27048), +(27049), +(27050), +(27051), +(27060), +(27065), +(27067), +(27068), +(27069), +(27070), +(27071), +(27072), +(27073), +(27074), +(27075), +(27078), +(27079), +(27126), +(27132), +(27135), +(27136), +(27137), +(27138), +(27140), +(27142), +(27154), +(27174), +(27175), +(27176), +(27177), +(27180), +(27187), +(27189), +(27209), +(27210), +(27211), +(27215), +(27216), +(27217), +(27218), +(27219), +(27220), +(27223), +(27224), +(27228), +(27243), +(27254), +(27255), +(27258), +(27261), +(27263), +(27267), +(27270), +(27274), +(27275), +(27276), +(27277), +(27281), +(27286), +(27288), +(27290), +(27360), +(27375), +(27376), +(27378), +(27379), +(27380), +(27381), +(27384), +(27385), +(27386), +(27387), +(27389), +(27390), +(27391), +(27392), +(27393), +(27395), +(27396), +(27397), +(27398), +(27441), +(27448), +(27486), +(27526), +(27527), +(27532), +(27541), +(27547), +(27548), +(27549), +(27550), +(27552), +(27553), +(27554), +(27555), +(27556), +(27557), +(27559), +(27565), +(27567), +(27571), +(27572), +(27573), +(27576), +(27577), +(27580), +(27581), +(27582), +(27584), +(27605), +(27606), +(27608), +(27609), +(27611), +(27613), +(27615), +(27620), +(27624), +(27626), +(27632), +(27633), +(27634), +(27635), +(27636), +(27637), +(27638), +(27640), +(27648), +(27655), +(27662), +(27673), +(27677), +(27686), +(27752), +(27754), +(27755), +(27756), +(27760), +(27765), +(27794), +(27806), +(27814), +(27819), +(27841), +(27849), +(27852), +(27860), +(27861), +(27863), +(27864), +(27865), +(27868), +(27873), +(27874), +(27891), +(27907), +(27909), +(27910), +(27915), +(27919), +(27931), +(27937), +(27983), +(27991), +(27992), +(27994), +(27995), +(28030), +(28099), +(28133), +(28147), +(28149), +(28167), +(28169), +(28239), +(28251), +(28252), +(28253), +(28254), +(28255), +(28256), +(28257), +(28258), +(28259), +(28260), +(28261), +(28262), +(28263), +(28265), +(28271), +(28272), +(28276), +(28287), +(28293), +(28299), +(28301), +(28303), +(28306), +(28308), +(28310), +(28314), +(28318), +(28319), +(28320), +(28321), +(28329), +(28336), +(28337), +(28342), +(28350), +(28351), +(28375), +(28393), +(28394), +(28396), +(28397), +(28410), +(28412), +(28418), +(28419), +(28420), +(28428), +(28431), +(28434), +(28439), +(28444), +(28445), +(28467), +(28470), +(28478), +(28516), +(28522), +(28597), +(28601), +(28608), +(28614), +(28624), +(28674), +(28676), +(28678), +(28684), +(28685), +(28689), +(28690), +(28691), +(28692), +(28696), +(28698), +(28702), +(28715), +(28718), +(28720), +(28722), +(28723), +(28724), +(28734), +(28750), +(28772), +(28776), +(28783), +(28788), +(28790), +(28791), +(28793), +(28795), +(28810), +(28824), +(28825), +(28826), +(28827), +(28836), +(28839), +(28858), +(28859), +(28872), +(28873), +(28880), +(28882), +(28883), +(28887), +(28896), +(28899), +(28900), +(28901), +(28902), +(28913), +(28969), +(28993), +(29001), +(29002), +(29003), +(29006), +(29044), +(29054), +(29058), +(29060), +(29098), +(29117), +(29126), +(29127), +(29128), +(29129), +(29134), +(29135), +(29136), +(29137), +(29138), +(29139), +(29151), +(29155), +(29157), +(29158), +(29160), +(29164), +(29166), +(29168), +(29170), +(29175), +(29182), +(29185), +(29188), +(29194), +(29196), +(29198), +(29228), +(29290), +(29295), +(29300), +(29306), +(29314), +(29317), +(29319), +(29320), +(29341), +(29362), +(29364), +(29380), +(29386), +(29395), +(29405), +(29407), +(29408), +(29425), +(29426), +(29427), +(29428), +(29435), +(29436), +(29443), +(29473), +(29487), +(29492), +(29494), +(29495), +(29497), +(29500), +(29502), +(29515), +(29516), +(29519), +(29522), +(29528), +(29539), +(29540), +(29543), +(29544), +(29546), +(29555), +(29560), +(29561), +(29562), +(29563), +(29564), +(29567), +(29570), +(29572), +(29574), +(29575), +(29576), +(29577), +(29578), +(29580), +(29581), +(29582), +(29583), +(29585), +(29586), +(29587), +(29607), +(29609), +(29638), +(29639), +(29640), +(29641), +(29644), +(29646), +(29647), +(29652), +(29653), +(29655), +(29661), +(29665), +(29666), +(29667), +(29670), +(29673), +(29675), +(29676), +(29677), +(29679), +(29684), +(29690), +(29703), +(29704), +(29707), +(29711), +(29712), +(29716), +(29722), +(29765), +(29768), +(29815), +(29832), +(29845), +(29847), +(29848), +(29850), +(29879), +(29881), +(29896), +(29901), +(29903), +(29906), +(29907), +(29909), +(29915), +(29916), +(29917), +(29925), +(29926), +(29927), +(29928), +(29930), +(29953), +(29954), +(29955), +(29956), +(29964), +(29990), +(29991), +(30010), +(30013), +(30014), +(30016), +(30019), +(30022), +(30036), +(30039), +(30044), +(30050), +(30053), +(30055), +(30069), +(30070), +(30077), +(30081), +(30099), +(30100), +(30102), +(30103), +(30104), +(30105), +(30108), +(30112), +(30113), +(30115), +(30121), +(30127), +(30128), +(30130), +(30131), +(30151), +(30153), +(30164), +(30173), +(30175), +(30177), +(30178), +(30180), +(30194), +(30195), +(30197), +(30198), +(30202), +(30213), +(30218), +(30219), +(30223), +(30238), +(30253), +(30269), +(30270), +(30271), +(30280), +(30285), +(30324), +(30330), +(30335), +(30351), +(30353), +(30356), +(30357), +(30358), +(30383), +(30395), +(30400), +(30401), +(30402), +(30404), +(30405), +(30412), +(30421), +(30422), +(30423), +(30424), +(30430), +(30433), +(30435), +(30448), +(30449), +(30451), +(30455), +(30459), +(30463), +(30464), +(30465), +(30466), +(30467), +(30468), +(30471), +(30474), +(30478), +(30479), +(30481), +(30493), +(30495), +(30500), +(30501), +(30504), +(30505), +(30507), +(30512), +(30520), +(30528), +(30530), +(30545), +(30546), +(30601), +(30605), +(30606), +(30607), +(30608), +(30609), +(30614), +(30615), +(30619), +(30621), +(30637), +(30638), +(30639), +(30641), +(30643), +(30646), +(30647), +(30648), +(30651), +(30652), +(30653), +(30654), +(30661), +(30686), +(30687), +(30688), +(30689), +(30691), +(30695), +(30719), +(30736), +(30740), +(30751), +(30753), +(30755), +(30756), +(30768), +(30817), +(30822), +(30830), +(30832), +(30838), +(30839), +(30846), +(30849), +(30850), +(30854), +(30875), +(30876), +(30877), +(30878), +(30888), +(30889), +(30890), +(30900), +(30901), +(30909), +(30910), +(30923), +(30926), +(30932), +(30936), +(30937), +(30942), +(30943), +(30944), +(30945), +(30967), +(30971), +(30977), +(30980), +(30981), +(30984), +(30986), +(30989), +(30990), +(30992), +(31008), +(31009), +(31012), +(31015), +(31016), +(31018), +(31022), +(31041), +(31042), +(31043), +(31046), +(31069), +(31117), +(31125), +(31139), +(31249), +(31257), +(31262), +(31263), +(31270), +(31271), +(31272), +(31274), +(31275), +(31279), +(31280), +(31281), +(31282), +(31284), +(31286), +(31287), +(31288), +(31289), +(31290), +(31292), +(31295), +(31296), +(31305), +(31306), +(31312), +(31316), +(31319), +(31330), +(31334), +(31337), +(31339), +(31345), +(31366), +(31367), +(31368), +(31376), +(31378), +(31381), +(31387), +(31389), +(31390), +(31394), +(31397), +(31399), +(31400), +(31401), +(31402), +(31404), +(31405), +(31406), +(31407), +(31410), +(31415), +(31416), +(31417), +(31418), +(31419), +(31420), +(31423), +(31425), +(31426), +(31427), +(31436), +(31445), +(31446), +(31457), +(31464), +(31477), +(31481), +(31486), +(31513), +(31516), +(31535), +(31547), +(31551), +(31552), +(31553), +(31566), +(31589), +(31595), +(31596), +(31600), +(31601), +(31602), +(31604), +(31609), +(31610), +(31618), +(31620), +(31622), +(31623), +(31626), +(31627), +(31629), +(31651), +(31662), +(31664), +(31703), +(31705), +(31707), +(31709), +(31713), +(31715), +(31717), +(31718), +(31721), +(31724), +(31729), +(31733), +(31734), +(31739), +(31740), +(31741), +(31742), +(31743), +(31747), +(31751), +(31754), +(31758), +(31759), +(31764), +(31766), +(31772), +(31779), +(31782), +(31784), +(31789), +(31790), +(31803), +(31804), +(31807), +(31808), +(31810), +(31811), +(31812), +(31813), +(31814), +(31815), +(31816), +(31819), +(31827), +(31843), +(31863), +(31864), +(31865), +(31893), +(31898), +(31907), +(31911), +(31916), +(31923), +(31935), +(31939), +(31942), +(31946), +(31948), +(31955), +(31956), +(31961), +(31965), +(31966), +(31971), +(31972), +(31973), +(31975), +(31976), +(31977), +(31978), +(31984), +(31988), +(31994), +(31996), +(31999), +(32000), +(32001), +(32002), +(32004), +(32005), +(32006), +(32009), +(32010), +(32011), +(32012), +(32013), +(32015), +(32017), +(32018), +(32019), +(32020), +(32021), +(32022), +(32024), +(32025), +(32026), +(32039), +(32049), +(32055), +(32056), +(32063), +(32065), +(32071), +(32076), +(32077), +(32080), +(32082), +(32092), +(32093), +(32094), +(32095), +(32103), +(32104), +(32105), +(32110), +(32120), +(32125), +(32126), +(32129), +(32131), +(32132), +(32133), +(32139), +(32154), +(32168), +(32175), +(32176), +(32190), +(32197), +(32202), +(32211), +(32224), +(32231), +(32247), +(32248), +(32261), +(32268), +(32270), +(32300), +(32306), +(32315), +(32317), +(32319), +(32320), +(32321), +(32323), +(32325), +(32328), +(32329), +(32330), +(32337), +(32338), +(32346), +(32361), +(32363), +(32364), +(32369), +(32370), +(32376), +(32378), +(32379), +(32386), +(32388), +(32389), +(32390), +(32391), +(32405), +(32414), +(32415), +(32416), +(32417), +(32418), +(32422), +(32428), +(32430), +(32431), +(32441), +(32445), +(32474), +(32491), +(32546), +(32550), +(32578), +(32583), +(32588), +(32593), +(32594), +(32595), +(32605), +(32606), +(32639), +(32643), +(32645), +(32652), +(32654), +(32666), +(32674), +(32675), +(32677), +(32678), +(32679), +(32682), +(32683), +(32684), +(32689), +(32690), +(32691), +(32693), +(32699), +(32700), +(32707), +(32709), +(32716), +(32721), +(32733), +(32734), +(32735), +(32736), +(32738), +(32739), +(32740), +(32741), +(32742), +(32747), +(32748), +(32749), +(32751), +(32752), +(32759), +(32769), +(32770), +(32771), +(32772), +(32774), +(32778), +(32779), +(32784), +(32797), +(32829), +(32830), +(32831), +(32835), +(32846), +(32858), +(32860), +(32862), +(32863), +(32864), +(32889), +(32897), +(32901), +(32902), +(32903), +(32904), +(32905), +(32906), +(32907), +(32908), +(32909), +(32913), +(32915), +(32916), +(32917), +(32919), +(32921), +(32922), +(32924), +(32926), +(32935), +(32940), +(32950), +(32959), +(32960), +(32962), +(32967), +(32969), +(32971), +(32984), +(32996), +(33031), +(33040), +(33044), +(33045), +(33047), +(33049), +(33051), +(33055), +(33056), +(33068), +(33069), +(33072), +(33073), +(33074), +(33077), +(33078), +(33079), +(33080), +(33081), +(33082), +(33086), +(33096), +(33098), +(33126), +(33129), +(33130), +(33144), +(33173), +(33175), +(33196), +(33197), +(33198), +(33206), +(33227), +(33230), +(33246), +(33247), +(33324), +(33326), +(33331), +(33335), +(33346), +(33360), +(33382), +(33383), +(33385), +(33387), +(33389), +(33392), +(33401), +(33404), +(33417), +(33419), +(33462), +(33463), +(33480), +(33482), +(33483), +(33487), +(33493), +(33502), +(33526), +(33527), +(33528), +(33529), +(33534), +(33535), +(33542), +(33552), +(33553), +(33554), +(33619), +(33620), +(33625), +(33626), +(33628), +(33631), +(33632), +(33640), +(33641), +(33643), +(33659), +(33661), +(33665), +(33684), +(33688), +(33689), +(33698), +(33699), +(33700), +(33709), +(33723), +(33728), +(33731), +(33745), +(33750), +(33763), +(33768), +(33781), +(33786), +(33787), +(33789), +(33792), +(33793), +(33794), +(33813), +(33824), +(33825), +(33827), +(33832), +(33833), +(33837), +(33844), +(33849), +(33850), +(33865), +(33871), +(33876), +(33878), +(33899), +(33907), +(33910), +(33911), +(33912), +(33913), +(33914), +(33925), +(33938), +(33947), +(33951), +(33960), +(33964), +(33969), +(33970), +(33975), +(33982), +(33983), +(33985), +(33986), +(33987), +(33988), +(33989), +(34014), +(34020), +(34025), +(34036), +(34071), +(34073), +(34083), +(34087), +(34088), +(34089), +(34092), +(34093), +(34095), +(34097), +(34099), +(34107), +(34108), +(34110), +(34112), +(34113), +(34120), +(34130), +(34132), +(34135), +(34138), +(34139), +(34143), +(34149), +(34150), +(34163), +(34171), +(34172), +(34176), +(34177), +(34213), +(34214), +(34215), +(34216), +(34217), +(34218), +(34219), +(34232), +(34243), +(34259), +(34298), +(34344), +(34345), +(34346), +(34347), +(34348), +(34351), +(34352), +(34353), +(34354), +(34357), +(34361), +(34363), +(34366), +(34370), +(34379), +(34389), +(34390), +(34391), +(34394), +(34400), +(34411), +(34412), +(34413), +(34414), +(34415), +(34416), +(34417), +(34418), +(34419), +(34423), +(34425), +(34428), +(34432), +(34437), +(34438), +(34439), +(34445), +(34446), +(34447), +(34451), +(34463), +(34490), +(34510), +(34520), +(34578), +(34580), +(34587), +(34613), +(34614), +(34615), +(34616), +(34618), +(34620), +(34625), +(34626), +(34629), +(34637), +(34639), +(34640), +(34641), +(34643), +(34644), +(34645), +(34650), +(34653), +(34654), +(34655), +(34661), +(34665), +(34672), +(34694), +(34695), +(34696), +(34697), +(34709), +(34714), +(34715), +(34719), +(34722), +(34745), +(34752), +(34784), +(34786), +(34787), +(34788), +(34789), +(34793), +(34794), +(34797), +(34798), +(34799), +(34800), +(34802), +(34809), +(34811), +(34812), +(34820), +(34824), +(34828), +(34829), +(34841), +(34852), +(34856), +(34875), +(34879), +(34881), +(34883), +(34886), +(34889), +(34891), +(34893), +(34906), +(34907), +(34913), +(34914), +(34916), +(34917), +(34920), +(34922), +(34924), +(34925), +(34930), +(34931), +(34940), +(34941), +(34942), +(34945), +(34969), +(34974), +(34975), +(34976), +(34984), +(34996), +(35004), +(35010), +(35011), +(35012), +(35013), +(35033), +(35034), +(35039), +(35047), +(35049), +(35054), +(35055), +(35056), +(35062), +(35065), +(35066), +(35067), +(35069), +(35071), +(35072), +(35088), +(35089), +(35092), +(35096), +(35101), +(35105), +(35106), +(35107), +(35112), +(35115), +(35117), +(35120), +(35144), +(35147), +(35161), +(35178), +(35179), +(35180), +(35182), +(35183), +(35185), +(35189), +(35195), +(35201), +(35207), +(35229), +(35231), +(35234), +(35238), +(35243), +(35244), +(35263), +(35267), +(35273), +(35280), +(35290), +(35291), +(35292), +(35293), +(35294), +(35295), +(35313), +(35314), +(35316), +(35317), +(35318), +(35321), +(35323), +(35325), +(35326), +(35328), +(35329), +(35331), +(35332), +(35333), +(35334), +(35335), +(35339), +(35346), +(35353), +(35371), +(35376), +(35377), +(35382), +(35387), +(35389), +(35392), +(35395), +(35401), +(35410), +(35412), +(35424), +(35460), +(35466), +(35472), +(35473), +(35493), +(35499), +(35501), +(35506), +(35507), +(35510), +(35511), +(35514), +(35518), +(35519), +(35556), +(35570), +(35621), +(35686), +(35718), +(35727), +(35728), +(35735), +(35741), +(35742), +(35748), +(35759), +(35760), +(35771), +(35772), +(35780), +(35783), +(35839), +(35846), +(35851), +(35853), +(35857), +(35871), +(35873), +(35877), +(35913), +(35914), +(35916), +(35918), +(35919), +(35920), +(35927), +(35928), +(35932), +(35944), +(35945), +(35946), +(35949), +(35954), +(35955), +(35963), +(35964), +(35965), +(35966), +(35967), +(35968), +(35969), +(35970), +(35971), +(35972), +(35973), +(35974), +(35975), +(35976), +(35977), +(35978), +(35979), +(35980), +(35981), +(35982), +(35983), +(35984), +(35985), +(35986), +(35987), +(35988), +(35989), +(35990), +(35997), +(35998), +(35999), +(36002), +(36020), +(36021), +(36023), +(36025), +(36033), +(36052), +(36054), +(36073), +(36088), +(36093), +(36094), +(36095), +(36099), +(36100), +(36102), +(36115), +(36123), +(36138), +(36140), +(36141), +(36145), +(36152), +(36153), +(36170), +(36173), +(36176), +(36181), +(36207), +(36208), +(36224), +(36227), +(36228), +(36237), +(36238), +(36246), +(36247), +(36250), +(36276), +(36277), +(36279), +(36288), +(36295), +(36296), +(36299), +(36310), +(36312), +(36314), +(36328), +(36332), +(36333), +(36339), +(36340), +(36341), +(36342), +(36343), +(36344), +(36345), +(36348), +(36380), +(36398), +(36399), +(36401), +(36402), +(36404), +(36414), +(36415), +(36416), +(36417), +(36433), +(36434), +(36435), +(36436), +(36438), +(36439), +(36441), +(36447), +(36448), +(36457), +(36458), +(36461), +(36464), +(36469), +(36470), +(36475), +(36478), +(36482), +(36483), +(36488), +(36500), +(36507), +(36508), +(36509), +(36516), +(36517), +(36518), +(36527), +(36534), +(36536), +(36538), +(36539), +(36540), +(36541), +(36554), +(36558), +(36570), +(36571), +(36578), +(36586), +(36590), +(36594), +(36601), +(36604), +(36606), +(36608), +(36609), +(36612), +(36622), +(36623), +(36624), +(36625), +(36627), +(36628), +(36632), +(36638), +(36641), +(36642), +(36645), +(36646), +(36647), +(36650), +(36655), +(36656), +(36659), +(36664), +(36671), +(36677), +(36678), +(36679), +(36710), +(36711), +(36712), +(36713), +(36714), +(36732), +(36739), +(36778), +(36779), +(36780), +(36781), +(36787), +(36789), +(36791), +(36796), +(36801), +(36805), +(36806), +(36807), +(36810), +(36812), +(36814), +(36822), +(36825), +(36831), +(36832), +(36833), +(36836), +(36838), +(36839), +(36840), +(36841), +(36842), +(36843), +(36844), +(36863), +(36864), +(36866), +(36872), +(36876), +(36877), +(36886), +(36891), +(36894), +(36905), +(36906), +(36909), +(36913), +(36914), +(36916), +(36917), +(36919), +(36920), +(36921), +(36924), +(36927), +(36929), +(36947), +(36956), +(36957), +(36965), +(36966), +(36971), +(36972), +(36974), +(36979), +(36980), +(36983), +(36984), +(36986), +(36987), +(36988), +(36990), +(36991), +(37027), +(37028), +(37030), +(37031), +(37054), +(37057), +(37067), +(37073), +(37074), +(37082), +(37089), +(37104), +(37110), +(37111), +(37112), +(37113), +(37121), +(37122), +(37123), +(37126), +(37132), +(37133), +(37136), +(37138), +(37154), +(37156), +(37162), +(37176), +(37208), +(37216), +(37221), +(37249), +(37250), +(37251), +(37252), +(37254), +(37255), +(37257), +(37259), +(37260), +(37271), +(37272), +(37273), +(37274), +(37275), +(37276), +(37277), +(37320), +(37321), +(37322), +(37323), +(37328), +(37329), +(37330), +(37331), +(37332), +(37334), +(37335), +(37359), +(37361), +(37369), +(37372), +(37387), +(37389), +(37412), +(37417), +(37421), +(37450), +(37455), +(37456), +(37460), +(37462), +(37463), +(37470), +(37479), +(37486), +(37500), +(37506), +(37511), +(37527), +(37532), +(37537), +(37540), +(37548), +(37551), +(37552), +(37554), +(37563), +(37566), +(37572), +(37577), +(37578), +(37579), +(37580), +(37581), +(37589), +(37591), +(37592), +(37596), +(37597), +(37599), +(37602), +(37621), +(37628), +(37629), +(37630), +(37632), +(37634), +(37646), +(37647), +(37654), +(37661), +(37662), +(37664), +(37667), +(37668), +(37675), +(37681), +(37685), +(37695), +(37700), +(37711), +(37717), +(37718), +(37719), +(37727), +(37749), +(37770), +(37777), +(37778), +(37798), +(37800), +(37801), +(37802), +(37803), +(37804), +(37805), +(37806), +(37807), +(37808), +(37809), +(37810), +(37811), +(37813), +(37823), +(37834), +(37838), +(37839), +(37840), +(37841), +(37847), +(37850), +(37851), +(37856), +(37862), +(37865), +(37867), +(37871), +(37892), +(37894), +(37906), +(37908), +(37910), +(37921), +(37922), +(37930), +(37933), +(37937), +(37940), +(37945), +(37946), +(37950), +(37956), +(37958), +(37962), +(37965), +(37967), +(37968), +(37972), +(37973), +(37974), +(37975), +(37978), +(37979), +(37986), +(37988), +(37992), +(37998), +(38002), +(38007), +(38009), +(38010), +(38023), +(38024), +(38025), +(38027), +(38029), +(38030), +(38032), +(38034), +(38035), +(38047), +(38048), +(38051), +(38052), +(38053), +(38056), +(38058), +(38059), +(38063), +(38065), +(38066), +(38067), +(38074), +(38075), +(38076), +(38078), +(38083), +(38084), +(38085), +(38093), +(38094), +(38095), +(38107), +(38109), +(38113), +(38120), +(38122), +(38125), +(38127), +(38129), +(38133), +(38134), +(38135), +(38136), +(38145), +(38146), +(38147), +(38148), +(38149), +(38153), +(38154), +(38155), +(38167), +(38177), +(38178), +(38182), +(38183), +(38187), +(38193), +(38203), +(38204), +(38205), +(38208), +(38209), +(38210), +(38213), +(38223), +(38226), +(38233), +(38234), +(38238), +(38239), +(38240), +(38243), +(38245), +(38246), +(38252), +(38253), +(38254), +(38259), +(38260), +(38262), +(38263), +(38264), +(38265), +(38267), +(38274), +(38275), +(38276), +(38277), +(38279), +(38280), +(38285), +(38295), +(38310), +(38313), +(38324), +(38328), +(38329), +(38330), +(38333), +(38338), +(38340), +(38342), +(38344), +(38363), +(38366), +(38370), +(38372), +(38374), +(38377), +(38378), +(38383), +(38386), +(38387), +(38391), +(38400), +(38401), +(38441), +(38446), +(38461), +(38465), +(38470), +(38474), +(38495), +(38496), +(38505), +(38509), +(38510), +(38520), +(38523), +(38526), +(38534), +(38535), +(38538), +(38543), +(38554), +(38556), +(38557), +(38558), +(38559), +(38560), +(38561), +(38562), +(38563), +(38564), +(38565), +(38566), +(38567), +(38568), +(38569), +(38570), +(38572), +(38580), +(38582), +(38584), +(38585), +(38586), +(38588), +(38591), +(38595), +(38598), +(38606), +(38616), +(38617), +(38621), +(38625), +(38626), +(38628), +(38630), +(38631), +(38634), +(38636), +(38641), +(38643), +(38645), +(38657), +(38658), +(38661), +(38663), +(38669), +(38692), +(38697), +(38699), +(38704), +(38708), +(38721), +(38723), +(38731), +(38739), +(38742), +(38753), +(38760), +(38762), +(38764), +(38765), +(38767), +(38768), +(38770), +(38772), +(38775), +(38777), +(38791), +(38797), +(38798), +(38801), +(38804), +(38806), +(38807), +(38808), +(38815), +(38816), +(38817), +(38821), +(38822), +(38823), +(38824), +(38825), +(38826), +(38827), +(38846), +(38848), +(38849), +(38851), +(38852), +(38858), +(38859), +(38861), +(38863), +(38864), +(38875), +(38879), +(38880), +(38881), +(38882), +(38883), +(38884), +(38887), +(38894), +(38895), +(38896), +(38897), +(38899), +(38904), +(38907), +(38909), +(38913), +(38914), +(38915), +(38918), +(38919), +(38921), +(38923), +(38926), +(38930), +(38935), +(38940), +(38941), +(38942), +(38943), +(38945), +(38946), +(38950), +(38952), +(38959), +(38967), +(38971), +(38985), +(38986), +(38987), +(38988), +(38989), +(38990), +(38992), +(38995), +(39000), +(39002), +(39006), +(39009), +(39015), +(39016), +(39017), +(39019), +(39020), +(39021), +(39022), +(39023), +(39025), +(39026), +(39029), +(39032), +(39039), +(39044), +(39046), +(39047), +(39053), +(39054), +(39058), +(39060), +(39061), +(39062), +(39064), +(39065), +(39066), +(39068), +(39069), +(39070), +(39076), +(39077), +(39078), +(39079), +(39083), +(39087), +(39097), +(39098), +(39099), +(39101), +(39116), +(39119), +(39120), +(39121), +(39122), +(39123), +(39125), +(39129), +(39135), +(39136), +(39145), +(39153), +(39157), +(39159), +(39160), +(39164), +(39165), +(39171), +(39172), +(39174), +(39176), +(39182), +(39192), +(39196), +(39197), +(39198), +(39202), +(39204), +(39207), +(39210), +(39212), +(39214), +(39215), +(39226), +(39229), +(39230), +(39252), +(39258), +(39262), +(39267), +(39268), +(39270), +(39271), +(39285), +(39293), +(39297), +(39299), +(39309), +(39322), +(39328), +(39329), +(39332), +(39337), +(39339), +(39349), +(39367), +(39371), +(39378), +(39386), +(39396), +(39412), +(39413), +(39415), +(39419), +(39435), +(39436), +(39445), +(39449), +(39456), +(39457), +(39460), +(39474), +(39475), +(39476), +(39477), +(39512), +(39513), +(39528), +(39529), +(39544), +(39560), +(39566), +(39574), +(39582), +(39587), +(39590), +(39592), +(39595), +(39600), +(39609), +(39621), +(39622), +(39661), +(39665), +(39668), +(39669), +(39670), +(39674), +(39675), +(39676), +(39697), +(39703), +(39794), +(39796), +(39810), +(39812), +(39826), +(39830), +(39835), +(39837), +(39838), +(39857), +(39865), +(39883), +(39886), +(39901), +(39904), +(39908), +(39920), +(39928), +(39945), +(39948), +(39955), +(39956), +(39967), +(39972), +(39979), +(39980), +(39995), +(39996), +(40011), +(40019), +(40032), +(40041), +(40055), +(40057), +(40063), +(40066), +(40071), +(40074), +(40081), +(40084), +(40086), +(40097), +(40099), +(40102), +(40109), +(40119), +(40123), +(40124), +(40146), +(40157), +(40165), +(40166), +(40167), +(40173), +(40185), +(40191), +(40193), +(40197), +(40198), +(40199), +(40220), +(40225), +(40227), +(40228), +(40239), +(40248), +(40251), +(40254), +(40259), +(40279), +(40290), +(40293), +(40303), +(40310), +(40311), +(40312), +(40313), +(40317), +(40321), +(40322), +(40325), +(40327), +(40334), +(40337), +(40339), +(40344), +(40346), +(40347), +(40348), +(40351), +(40356), +(40357), +(40358), +(40363), +(40366), +(40367), +(40368), +(40384), +(40385), +(40392), +(40400), +(40406), +(40411), +(40412), +(40413), +(40414), +(40415), +(40416), +(40420), +(40423), +(40427), +(40429), +(40430), +(40431), +(40434), +(40449), +(40450), +(40471), +(40472), +(40481), +(40486), +(40489), +(40491), +(40493), +(40497), +(40504), +(40505), +(40507), +(40508), +(40509), +(40525), +(40536), +(40542), +(40554), +(40560), +(40563), +(40564), +(40565), +(40569), +(40571), +(40581), +(40585), +(40595), +(40597), +(40602), +(40604), +(40605), +(40608), +(40616), +(40620), +(40633), +(40635), +(40639), +(40641), +(40643), +(40645), +(40646), +(40651), +(40652), +(40671), +(40672), +(40685), +(40726), +(40728), +(40736), +(40739), +(40740), +(40742), +(40751), +(40758), +(40770), +(40772), +(40777), +(40778), +(40787), +(40796), +(40801), +(40810), +(40814), +(40822), +(40827), +(40835), +(40837), +(40838), +(40842), +(40843), +(40844), +(40846), +(40856), +(40859), +(40860), +(40861), +(40864), +(40872), +(40873), +(40876), +(40877), +(40881), +(40886), +(40888), +(40890), +(40892), +(40893), +(40894), +(40895), +(40901), +(40903), +(40906), +(40909), +(40917), +(40926), +(40928), +(40930), +(40935), +(40945), +(40951), +(40954), +(40958), +(40964), +(40965), +(40968), +(40969), +(40970), +(40972), +(40976), +(40991), +(41001), +(41003), +(41028), +(41029), +(41032), +(41035), +(41044), +(41047), +(41050), +(41052), +(41054), +(41055), +(41060), +(41063), +(41065), +(41069), +(41070), +(41072), +(41075), +(41080), +(41082), +(41083), +(41084), +(41092), +(41093), +(41103), +(41109), +(41115), +(41116), +(41121), +(41137), +(41139), +(41152), +(41169), +(41170), +(41171), +(41177), +(41178), +(41179), +(41180), +(41182), +(41183), +(41184), +(41186), +(41187), +(41188), +(41189), +(41190), +(41192), +(41197), +(41198), +(41213), +(41214), +(41225), +(41226), +(41227), +(41228), +(41229), +(41230), +(41231), +(41238), +(41241), +(41247), +(41250), +(41255), +(41256), +(41259), +(41264), +(41265), +(41270), +(41272), +(41278), +(41279), +(41280), +(41281), +(41283), +(41291), +(41299), +(41302), +(41332), +(41334), +(41335), +(41336), +(41338), +(41345), +(41346), +(41351), +(41352), +(41353), +(41355), +(41360), +(41363), +(41368), +(41370), +(41372), +(41373), +(41374), +(41375), +(41377), +(41378), +(41383), +(41384), +(41388), +(41389), +(41390), +(41392), +(41394), +(41395), +(41396), +(41407), +(41410), +(41411), +(41419), +(41421), +(41426), +(41439), +(41440), +(41442), +(41448), +(41450), +(41451), +(41456), +(41461), +(41467), +(41468), +(41470), +(41471), +(41472), +(41473), +(41483), +(41484), +(41485), +(41486), +(41487), +(41489), +(41490), +(41491), +(41492), +(41519), +(41526), +(41528), +(41533), +(41540), +(41543), +(41544), +(41546), +(41547), +(41548), +(41549), +(41558), +(41559), +(41563), +(41564), +(41565), +(41567), +(41568), +(41571), +(41578), +(41579), +(41580), +(41581), +(41586), +(41588), +(41592), +(41596), +(41597), +(41598), +(41601), +(41621), +(41622), +(41625), +(41626), +(41633), +(41637), +(41911), +(41914), +(41916), +(41917), +(41926), +(41931), +(41932), +(41933), +(41936), +(41937), +(41939), +(41940), +(41957), +(41958), +(41959), +(41960), +(41961), +(41964), +(41965), +(41978), +(41980), +(41984), +(41985), +(41990), +(42002), +(42003), +(42013), +(42018), +(42020), +(42021), +(42024), +(42025), +(42053), +(42058), +(42129), +(42131), +(42132), +(42133), +(42139), +(42142), +(42144), +(42149), +(42150), +(42152), +(42161), +(42165), +(42169), +(42185), +(42203), +(42246), +(42299), +(42313), +(42315), +(42319), +(42320), +(42322), +(42324), +(42325), +(42326), +(42328), +(42329), +(42330), +(42331), +(42332), +(42333), +(42337), +(42349), +(42360), +(42363), +(42368), +(42369), +(42370), +(42371), +(42372), +(42380), +(42382), +(42383), +(42384), +(42385), +(42389), +(42395), +(42396), +(42397), +(42399), +(42400), +(42401), +(42402), +(42411), +(42414), +(42426), +(42434), +(42435), +(42441), +(42443), +(42447), +(42455), +(42463), +(42476), +(42483), +(42485), +(42486), +(42488), +(42489), +(42502), +(42512), +(42514), +(42516), +(42518), +(42535), +(42537), +(42540), +(42560), +(42561), +(42574), +(42579), +(42580), +(42583), +(42587), +(42611), +(42628), +(42632), +(42633), +(42634), +(42635), +(42653), +(42658), +(42670), +(42671), +(42672), +(42696), +(42702), +(42710), +(42711), +(42717), +(42719), +(42721), +(42724), +(42725), +(42730), +(42733), +(42739), +(42740), +(42741), +(42746), +(42747), +(42756), +(42762), +(42767), +(42772), +(42780), +(42781), +(42782), +(42783), +(42785), +(42789), +(42790), +(42791), +(42793), +(42799), +(42802), +(42803), +(42804), +(42811), +(42826), +(42832), +(42833), +(42834), +(42841), +(42842), +(42843), +(42846), +(42853), +(42858), +(42859), +(42867), +(42869), +(42870), +(42872), +(42873), +(42878), +(42879), +(42880), +(42889), +(42890), +(42891), +(42894), +(42895), +(42896), +(42897), +(42902), +(42903), +(42904), +(42907), +(42908), +(42913), +(42914), +(42953), +(42964), +(42972), +(42978), +(42995), +(42999), +(43003), +(43004), +(43006), +(43036), +(43037), +(43043), +(43044), +(43058), +(43061), +(43063), +(43064), +(43065), +(43067), +(43075), +(43077), +(43083), +(43084), +(43086), +(43087), +(43090), +(43093), +(43094), +(43097), +(43100), +(43103), +(43104), +(43107), +(43108), +(43122), +(43123), +(43125), +(43128), +(43130), +(43131), +(43132), +(43133), +(43137), +(43138), +(43140), +(43150), +(43151), +(43153), +(43156), +(43157), +(43159), +(43178), +(43187), +(43191), +(43192), +(43193), +(43194), +(43195), +(43196), +(43197), +(43198), +(43199), +(43202), +(43205), +(43206), +(43225), +(43228), +(43235), +(43243), +(43245), +(43246), +(43256), +(43259), +(43260), +(43261), +(43262), +(43267), +(43268), +(43270), +(43273), +(43286), +(43287), +(43288), +(43292), +(43297), +(43298), +(43299), +(43300), +(43301), +(43303), +(43305), +(43309), +(43315), +(43325), +(43330), +(43334), +(43337), +(43340), +(43341), +(43345), +(43346), +(43347), +(43348), +(43352), +(43353), +(43354), +(43356), +(43357), +(43358), +(43359), +(43361), +(43362), +(43364), +(43365), +(43368), +(43370), +(43379), +(43380), +(43381), +(43384), +(43393), +(43398), +(43399), +(43409), +(43410), +(43411), +(43413), +(43415), +(43416), +(43417), +(43419), +(43427), +(43428), +(43433), +(43435), +(43439), +(43441), +(43445), +(43451), +(43456), +(43461), +(43469), +(43470), +(43471), +(43472), +(43473), +(43474), +(43475), +(43477), +(43483), +(43484), +(43488), +(43489), +(43492), +(43495), +(43496), +(43497), +(43501), +(43505), +(43507), +(43511), +(43512), +(43515), +(43516), +(43517), +(43518), +(43519), +(43520), +(43522), +(43523), +(43524), +(43525), +(43526), +(43528), +(43529), +(43532), +(43535), +(43543), +(43545), +(43553), +(43556), +(43560), +(43564), +(43565), +(43567), +(43569), +(43571), +(43572), +(43574), +(43575), +(43577), +(43578), +(43579), +(43581), +(43584), +(43585), +(43586), +(43591), +(43592), +(43593), +(43612), +(43613), +(43619), +(43621), +(43622), +(43644), +(43646), +(43648), +(43649), +(43650), +(43651), +(43660), +(43661), +(43663), +(43665), +(43666), +(43667), +(43671), +(43673), +(43680), +(43682), +(43683), +(43684), +(43690), +(43693), +(43695), +(43701), +(43709), +(43714), +(43715), +(43720), +(43726), +(43727), +(43728), +(43729), +(43732), +(43746), +(43767), +(43769), +(43785), +(43786), +(43789), +(43794), +(43795), +(43799), +(43804), +(43807), +(43809), +(43821), +(43834), +(43869), +(43895), +(43903), +(43906), +(43923), +(43928), +(43931), +(43932), +(43933), +(43937), +(43941), +(43948), +(43951), +(43952), +(43969), +(43971), +(43974), +(43976), +(43984), +(43988), +(43993), +(43996), +(43997), +(44000), +(44005), +(44008), +(44015), +(44016), +(44030), +(44031), +(44038), +(44053), +(44078), +(44079), +(44081), +(44082), +(44089), +(44093), +(44095), +(44120), +(44121), +(44126), +(44127), +(44137), +(44138), +(44139), +(44141), +(44142), +(44144), +(44148), +(44149), +(44152), +(44156), +(44159), +(44164), +(44165), +(44168), +(44169), +(44170), +(44171), +(44173), +(44174), +(44176), +(44181), +(44185), +(44188), +(44189), +(44202), +(44211), +(44212), +(44216), +(44219), +(44220), +(44221), +(44222), +(44223), +(44237), +(44241), +(44242), +(44247), +(44248), +(44256), +(44258), +(44262), +(44267), +(44268), +(44271), +(44274), +(44280), +(44285), +(44286), +(44289), +(44294), +(44304), +(44308), +(44310), +(44318), +(44319), +(44323), +(44325), +(44327), +(44328), +(44332), +(44339), +(44351), +(44357), +(44358), +(44361), +(44364), +(44368), +(44370), +(44382), +(44407), +(44408), +(44415), +(44424), +(44425), +(44429), +(44430), +(44454), +(44455), +(44457), +(44464), +(44473), +(44477), +(44478), +(44479), +(44481), +(44482), +(44503), +(44504), +(44512), +(44518), +(44519), +(44525), +(44530), +(44532), +(44533), +(44534), +(44536), +(44541), +(44542), +(44547), +(44553), +(44563), +(44564), +(44572), +(44577), +(44583), +(44586), +(44600), +(44602), +(44606), +(44614), +(44617), +(44618), +(44619), +(44620), +(44622), +(44639), +(44640), +(44641), +(44642), +(44654), +(44657), +(44658), +(44685), +(44732), +(44753), +(44755), +(44765), +(44780), +(44781), +(44787), +(44788), +(44789), +(44790), +(44791), +(44796), +(44808), +(44811), +(44812), +(44813), +(44817), +(44818), +(44823), +(44843), +(44848), +(44868), +(44871), +(44872), +(44876), +(44881), +(44934), +(44937), +(44945), +(44956), +(44957), +(44961), +(44966), +(44985), +(44997), +(45012), +(45017), +(45023), +(45026), +(45029), +(45031), +(45036), +(45055), +(45064), +(45071), +(45075), +(45088), +(45089), +(45090), +(45096), +(45101), +(45102), +(45105), +(45108), +(45110), +(45113), +(45123), +(45124), +(45129), +(45130), +(45133), +(45134), +(45141), +(45145), +(45185), +(45189), +(45192), +(45195), +(45197), +(45199), +(45200), +(45204), +(45205), +(45206), +(45209), +(45214), +(45215), +(45221), +(45228), +(45235), +(45251), +(45256), +(45269), +(45271), +(45274), +(45276), +(45280), +(45284), +(45286), +(45287), +(45288), +(45289), +(45290), +(45291), +(45292), +(45293), +(45294), +(45295), +(45296), +(45297), +(45298), +(45299), +(45300), +(45301), +(45302), +(45314), +(45321), +(45324), +(45327), +(45328), +(45334), +(45337), +(45344), +(45350), +(45352), +(45353), +(45356), +(45362), +(45409), +(45417), +(45419), +(45420), +(45421), +(45425), +(45428), +(45429), +(45430), +(45442), +(45444), +(45447), +(45456), +(45458), +(45462), +(45463), +(45468), +(45469), +(45472), +(45476), +(45477), +(45485), +(45487), +(45491), +(45493), +(45497), +(45504), +(45505), +(45507), +(45509), +(45511), +(45516), +(45524), +(45534), +(45537), +(45543), +(45544), +(45573), +(45576), +(45577), +(45578), +(45580), +(45587), +(45588), +(45589), +(45590), +(45600), +(45603), +(45604), +(45611), +(45625), +(45627), +(45628), +(45629), +(45632), +(45639), +(45645), +(45646), +(45647), +(45648), +(45649), +(45650), +(45659), +(45660), +(45661), +(45664), +(45693), +(45696), +(45716), +(45717), +(45719), +(45724), +(45725), +(45730), +(45739), +(45742), +(45744), +(45748), +(45773), +(45777), +(45778), +(45798), +(45799), +(45800), +(45803), +(45804), +(45815), +(45820), +(45833), +(45837), +(45854), +(45866), +(45873), +(45874), +(45875), +(45889), +(45897), +(45898), +(45899), +(45900), +(45902), +(45906), +(45913), +(45919), +(45924), +(45926), +(45931), +(45940), +(45943), +(45946), +(45947), +(45964), +(45967), +(45975), +(45980), +(45981), +(45983), +(45989), +(45992), +(46010), +(46012), +(46014), +(46015), +(46016), +(46023), +(46027), +(46028), +(46029), +(46031), +(46032), +(46033), +(46035), +(46042), +(46043), +(46044), +(46045), +(46047), +(46049), +(46057), +(46062), +(46065), +(46067), +(46070), +(46074), +(46080), +(46081), +(46083), +(46084), +(46092), +(46093), +(46098), +(46099), +(46101), +(46104), +(46119), +(46145), +(46152), +(46153), +(46155), +(46161), +(46164), +(46166), +(46167), +(46180), +(46181), +(46182), +(46183), +(46187), +(46188), +(46189), +(46190), +(46191), +(46192), +(46194), +(46198), +(46200), +(46202), +(46206), +(46221), +(46231), +(46232), +(46239), +(46260), +(46266), +(46276), +(46279), +(46280), +(46283), +(46285), +(46288), +(46291), +(46292), +(46305), +(46315), +(46323), +(46331), +(46333), +(46341), +(46357), +(46361), +(46362), +(46364), +(46365), +(46366), +(46368), +(46380), +(46381), +(46394), +(46406), +(46411), +(46420), +(46421), +(46422), +(46429), +(46430), +(46432), +(46433), +(46434), +(46440), +(46443), +(46444), +(46447), +(46448), +(46449), +(46459), +(46460), +(46466), +(46468), +(46469), +(46479), +(46480), +(46481), +(46483), +(46485), +(46486), +(46487), +(46543), +(46550), +(46556), +(46557), +(46558), +(46559), +(46560), +(46561), +(46562), +(46563), +(46566), +(46567), +(46568), +(46572), +(46579), +(46580), +(46582), +(46587), +(46590), +(46591), +(46595), +(46598), +(46602), +(46607), +(46611), +(46612), +(46613), +(46614), +(46615), +(46616), +(46617), +(46618), +(46620), +(46621), +(46624), +(46629), +(46630), +(46641), +(46642), +(46651), +(46654), +(46661), +(46664), +(46665), +(46667), +(46671), +(46672), +(46673), +(46674), +(46677), +(46681), +(46686), +(46691), +(46693), +(46696), +(46702), +(46704), +(46709), +(46711), +(46716), +(46717), +(46718), +(46719), +(46720), +(46721), +(46722), +(46723), +(46724), +(46725), +(46726), +(46727), +(46728), +(46729), +(46730), +(46731), +(46734), +(46745), +(46762), +(46764), +(46770), +(46772), +(46773), +(46787), +(46791), +(46801), +(46813), +(46816), +(46824), +(46825), +(46826), +(46841), +(46845), +(46846), +(46856), +(46857), +(46877), +(46879), +(46880), +(46887), +(46906), +(46956), +(46960), +(46962), +(46978), +(46982), +(46983), +(46987), +(46988), +(46990), +(47001), +(47003), +(47009), +(47011), +(47012), +(47014), +(47020), +(47021), +(47028), +(47029), +(47033), +(47034), +(47042), +(47043), +(47057), +(47059), +(47062), +(47063), +(47064), +(47066), +(47068), +(47069), +(47070), +(47071), +(47072), +(47074), +(47076), +(47077), +(47079), +(47081), +(47084), +(47093), +(47096), +(47098), +(47107), +(47117), +(47122), +(47139), +(47143), +(47144), +(47145), +(47146), +(47148), +(47149), +(47151), +(47152), +(47153), +(47155), +(47156), +(47157), +(47158), +(47160), +(47161), +(47162), +(47163), +(47164), +(47165), +(47166), +(47168), +(47171), +(47173), +(47176), +(47206), +(47208), +(47219), +(47244), +(47248), +(47249), +(47257), +(47272), +(47277), +(47282), +(47293), +(47299), +(47305), +(47307), +(47308), +(47316), +(47321), +(47322), +(47323), +(47326), +(47333), +(47334), +(47337), +(47338), +(47339), +(47340), +(47345), +(47380), +(47382), +(47390), +(47392), +(47394), +(47403), +(47405), +(47410), +(47413), +(47414), +(47422), +(47424), +(47431), +(47432), +(47442), +(47447), +(47449), +(47450), +(47451), +(47453), +(47465), +(47467), +(47468), +(47470), +(47471), +(47472), +(47474), +(47475), +(47476), +(47480), +(47481), +(47482), +(47485), +(47486), +(47487), +(47488), +(47489), +(47497), +(47498), +(47504), +(47516), +(47517), +(47519), +(47520), +(47528), +(47530), +(47534), +(47540), +(47541), +(47550), +(47575), +(47601), +(47604), +(47610), +(47611), +(47614), +(47629), +(47632), +(47633), +(47635), +(47637), +(47664), +(47665), +(47673), +(47674), +(47676), +(47679), +(47689), +(47695), +(47697), +(47698), +(47700), +(47702), +(47703), +(47718), +(47721), +(47722), +(47723), +(47724), +(47729), +(47739), +(47740), +(47741), +(47744), +(47749), +(47751), +(47753), +(47757), +(47758), +(47761), +(47767), +(47768), +(47777), +(47778), +(47780), +(47781), +(47782), +(47783), +(47785), +(47788), +(47808), +(47809), +(47810), +(47811), +(47812), +(47813), +(47814), +(47815), +(47824), +(47825), +(47826), +(47827), +(47835), +(47836), +(47837), +(47838), +(47841), +(47843), +(47848), +(47850), +(47851), +(47852), +(47853), +(47855), +(47857), +(47859), +(47860), +(47863), +(47864), +(47865), +(47867), +(47902), +(47914), +(47917), +(47920), +(47926), +(47928), +(47930), +(47938), +(47948), +(47960), +(47961), +(47962), +(47964), +(47968), +(47976), +(47984), +(47991), +(47992), +(47993), +(47994), +(47995), +(47996), +(48011), +(48013), +(48039), +(48045), +(48046), +(48047), +(48048), +(48053), +(48060), +(48062), +(48063), +(48065), +(48066), +(48067), +(48068), +(48070), +(48071), +(48072), +(48073), +(48084), +(48085), +(48098), +(48099), +(48100), +(48101), +(48102), +(48103), +(48104), +(48105), +(48119), +(48120), +(48122), +(48123), +(48124), +(48125), +(48126), +(48127), +(48130), +(48132), +(48133), +(48134), +(48135), +(48137), +(48140), +(48147), +(48155), +(48156), +(48157), +(48158), +(48159), +(48160), +(48161), +(48163), +(48164), +(48165), +(48169), +(48181), +(48184), +(48187), +(48192), +(48208), +(48210), +(48232), +(48245), +(48249), +(48250), +(48261), +(48262), +(48264), +(48267), +(48268), +(48282), +(48283), +(48285), +(48286), +(48287), +(48288), +(48290), +(48291), +(48292), +(48296), +(48298), +(48299), +(48300), +(48301), +(48307), +(48309), +(48310), +(48316), +(48330), +(48334), +(48360), +(48365), +(48374), +(48376), +(48377), +(48378), +(48400), +(48417), +(48423), +(48424), +(48440), +(48441), +(48442), +(48443), +(48450), +(48451), +(48459), +(48461), +(48462), +(48463), +(48464), +(48465), +(48468), +(48469), +(48479), +(48480), +(48489), +(48490), +(48491), +(48504), +(48532), +(48533), +(48540), +(48541), +(48542), +(48543), +(48548), +(48549), +(48563), +(48564), +(48565), +(48566), +(48567), +(48568), +(48569), +(48570), +(48571), +(48572), +(48573), +(48574), +(48575), +(48576), +(48577), +(48578), +(48579), +(48583), +(48585), +(48598), +(48599), +(48601), +(48603), +(48606), +(48617), +(48622), +(48628), +(48637), +(48638), +(48639), +(48640), +(48648), +(48652), +(48656), +(48657), +(48658), +(48659), +(48660), +(48661), +(48662), +(48663), +(48664), +(48665), +(48666), +(48667), +(48668), +(48669), +(48671), +(48672), +(48673), +(48674), +(48675), +(48676), +(48678), +(48679), +(48680), +(48689), +(48690), +(48691), +(48693), +(48696), +(48697), +(48698), +(48699), +(48700), +(48712), +(48714), +(48737), +(48738), +(48746), +(48747), +(48749), +(48750), +(48752), +(48753), +(48754), +(48755), +(48756), +(48759), +(48760), +(48765), +(48770), +(48772), +(48774), +(48775), +(48781), +(48782), +(48784), +(48785), +(48788), +(48800), +(48801), +(48802), +(48805), +(48806), +(48812), +(48813), +(48815), +(48820), +(48821), +(48822), +(48823), +(48824), +(48825), +(48826), +(48827), +(48828), +(48829), +(48830), +(48831), +(48832), +(48845), +(48850), +(48851), +(48852), +(48854), +(48862), +(48871), +(48872), +(48873), +(48876), +(48877), +(48878), +(48880), +(48881), +(48883), +(48895), +(48917), +(48920), +(48931), +(48932), +(48935), +(48936), +(48953), +(48960), +(48974), +(48981), +(48984), +(48995), +(48996), +(48998), +(48999), +(49000), +(49001), +(49005), +(49009), +(49010), +(49011), +(49012), +(49020), +(49021), +(49026), +(49028), +(49029), +(49037), +(49044), +(49045), +(49047), +(49048), +(49049), +(49050), +(49051), +(49052), +(49053), +(49054), +(49078), +(49084), +(49089), +(49090), +(49091), +(49092), +(49093), +(49099), +(49106), +(49110), +(49111), +(49113), +(49119), +(49124), +(49125), +(49127), +(49138), +(49143), +(49158), +(49161), +(49165), +(49177), +(49184), +(49204), +(49206), +(49213), +(49215), +(49230), +(49231), +(49232), +(49233), +(49235), +(49236), +(49237), +(49238), +(49239), +(49240), +(49242), +(49243), +(49256), +(49257), +(49266), +(49267), +(49268), +(49269), +(49270), +(49271), +(49272), +(49273), +(49275), +(49276), +(49278), +(49279), +(49282), +(49283), +(49284), +(49288), +(49294), +(49296), +(49298), +(49305), +(49309), +(49312), +(49317), +(49323), +(49324), +(49348), +(49349), +(49353), +(49354), +(49362), +(49363), +(49364), +(49372), +(49376), +(49381), +(49383), +(49387), +(49404), +(49406), +(49418), +(49427), +(49429), +(49433), +(49439), +(49446), +(49453), +(49454), +(49459), +(49463), +(49466), +(49481), +(49482), +(49485), +(49500), +(49501), +(49511), +(49512), +(49527), +(49537), +(49544), +(49546), +(49547), +(49549), +(49560), +(49576), +(49584), +(49587), +(49592), +(49613), +(49616), +(49617), +(49624), +(49637), +(49639), +(49641), +(49644), +(49675), +(49678), +(49680), +(49681), +(49686), +(49690), +(49696), +(49704), +(49705), +(49706), +(49708), +(49710), +(49711), +(49712), +(49715), +(49718), +(49719), +(49720), +(49723), +(49729), +(49734), +(49742), +(49747), +(49749), +(49753), +(49755), +(49758), +(49759), +(49771), +(49776), +(49797), +(49799), +(49800), +(49802), +(49803), +(49804), +(49805), +(49806), +(49830), +(49836), +(49840), +(49841), +(49843), +(49846), +(49848), +(49859), +(49861), +(49863), +(49865), +(49891), +(49892), +(49893), +(49894), +(49895), +(49896), +(49897), +(49903), +(49904), +(49906), +(49909), +(49913), +(49914), +(49915), +(49916), +(49917), +(49918), +(49919), +(49920), +(49921), +(49922), +(49923), +(49924), +(49926), +(49927), +(49928), +(49929), +(49930), +(49935), +(49942), +(49945), +(49956), +(49961), +(49965), +(49966), +(49967), +(49968), +(49969), +(49970), +(49971), +(49972), +(49973), +(49974), +(49975), +(49978), +(49980), +(49981), +(49985), +(49986), +(49987), +(49989), +(49991), +(49993), +(49994), +(49995), +(49996), +(49997), +(49998), +(49999), +(50004), +(50006), +(50015), +(50021), +(50027), +(50028), +(50035), +(50038), +(50046), +(50047), +(50050), +(50052), +(50064), +(50066), +(50073), +(50075), +(50084), +(50086), +(50089), +(50090), +(50091), +(50092), +(50094), +(50100), +(50101), +(50102), +(50104), +(50135), +(50144), +(50145), +(50146), +(50156), +(50165), +(50169), +(50183), +(50184), +(50185), +(50188), +(50196), +(50198), +(50205), +(50206), +(50207), +(50217), +(50231), +(50232), +(50234), +(50245), +(50251), +(50252), +(50255), +(50256), +(50257), +(50259), +(50265), +(50271), +(50273), +(50276), +(50282), +(50287), +(50288), +(50289), +(50290), +(50291), +(50293), +(50295), +(50299), +(50301), +(50303), +(50305), +(50306), +(50307), +(50319), +(50323), +(50328), +(50335), +(50341), +(50343), +(50344), +(50347), +(50349), +(50356), +(50361), +(50370), +(50375), +(50377), +(50378), +(50379), +(50380), +(50400), +(50401), +(50402), +(50403), +(50405), +(50406), +(50410), +(50411), +(50412), +(50424), +(50431), +(50432), +(50434), +(50435), +(50436), +(50437), +(50439), +(50445), +(50454), +(50455), +(50456), +(50459), +(50462), +(50463), +(50464), +(50477), +(50478), +(50479), +(50484), +(50498), +(50499), +(50500), +(50504), +(50508), +(50509), +(50510), +(50511), +(50512), +(50517), +(50518), +(50519), +(50521), +(50523), +(50533), +(50534), +(50536), +(50537), +(50538), +(50541), +(50545), +(50550), +(50559), +(50566), +(50572), +(50573), +(50578), +(50581), +(50582), +(50588), +(50597), +(50629), +(50631), +(50633), +(50634), +(50635), +(50638), +(50655), +(50658), +(50659), +(50660), +(50661), +(50662), +(50663), +(50666), +(50668), +(50673), +(50675), +(50679), +(50688), +(50691), +(50693), +(50701), +(50704), +(50705), +(50706), +(50721), +(50725), +(50729), +(50731), +(50732), +(50733), +(50737), +(50739), +(50740), +(50744), +(50761), +(50770), +(50773), +(50782), +(50783), +(50796), +(50797), +(50799), +(50804), +(50818), +(50820), +(50821), +(50830), +(50832), +(50834), +(50842), +(50843), +(50844), +(50845), +(50846), +(50853), +(50854), +(50859), +(50861), +(50874), +(50876), +(50894), +(50895), +(50900), +(50905), +(50907), +(50914), +(50918), +(50919), +(50923), +(50924), +(50926), +(50927), +(50978), +(50979), +(50992), +(50997), +(51011), +(51015), +(51016), +(51018), +(51020), +(51026), +(51035), +(51037), +(51046), +(51054), +(51055), +(51057), +(51059), +(51062), +(51064), +(51067), +(51069), +(51072), +(51077), +(51079), +(51081), +(51083), +(51085), +(51087), +(51089), +(51091), +(51093), +(51095), +(51097), +(51100), +(51102), +(51105), +(51107), +(51111), +(51120), +(51121), +(51131), +(51134), +(51135), +(51137), +(51154), +(51156), +(51157), +(51165), +(51187), +(51196), +(51197), +(51198), +(51199), +(51200), +(51203), +(51216), +(51220), +(51221), +(51226), +(51227), +(51228), +(51229), +(51232), +(51233), +(51235), +(51236), +(51240), +(51243), +(51258), +(51259), +(51270), +(51272), +(51275), +(51279), +(51285), +(51287), +(51290), +(51292), +(51298), +(51305), +(51308), +(51310), +(51315), +(51316), +(51325), +(51326), +(51327), +(51328), +(51330), +(51334), +(51339), +(51340), +(51354), +(51356), +(51363), +(51365), +(51372), +(51382), +(51399), +(51409), +(51410), +(51411), +(51413), +(51416), +(51417), +(51418), +(51419), +(51423), +(51424), +(51425), +(51426), +(51427), +(51428), +(51429), +(51430), +(51431), +(51432), +(51440), +(51442), +(51446), +(51447), +(51454), +(51460), +(51467), +(51484), +(51489), +(51491), +(51492), +(51495), +(51496), +(51500), +(51502), +(51503), +(51504), +(51505), +(51506), +(51509), +(51514), +(51515), +(51573), +(51580), +(51584), +(51585), +(51586), +(51587), +(51588), +(51591), +(51592), +(51593), +(51596), +(51598), +(51601), +(51608), +(51609), +(51610), +(51613), +(51614), +(51618), +(51656), +(51657), +(51658), +(51659), +(51662), +(51675), +(51676), +(51677), +(51680), +(51693), +(51695), +(51699), +(51714), +(51718), +(51722), +(51724), +(51726), +(51728), +(51732), +(51734), +(51735), +(51736), +(51740), +(51751), +(51756), +(51757), +(51772), +(51775), +(51776), +(51778), +(51779), +(51786), +(51787), +(51797), +(51798), +(51799), +(51803), +(51804), +(51808), +(51809), +(51811), +(51818), +(51827), +(51830), +(51842), +(51844), +(51853), +(51854), +(51855), +(51856), +(51857), +(51863), +(51864), +(51872), +(51875), +(51876), +(51877), +(51878), +(51879), +(51886), +(51888), +(51889), +(51893), +(51894), +(51895), +(51897), +(51898), +(51899), +(51901), +(51909), +(51912), +(51917), +(51918), +(51919), +(51920), +(51926), +(51934), +(51935), +(51936), +(51937), +(51940), +(51945), +(51949), +(51951), +(51961), +(51962), +(51963), +(51968), +(51973), +(51976), +(51979), +(51981), +(51989), +(51990), +(51997), +(51998), +(51999), +(52000), +(52004), +(52005), +(52007), +(52008), +(52014), +(52025), +(52026), +(52030), +(52032), +(52042), +(52043), +(52045), +(52053), +(52069), +(52078), +(52082), +(52083), +(52086), +(52088), +(52090), +(52108), +(52125), +(52139), +(52149), +(52157), +(52160), +(52163), +(52167), +(52169), +(52171), +(52187), +(52194), +(52196), +(52198), +(52199), +(52206), +(52207), +(52209), +(52210), +(52212), +(52217), +(52219), +(52221), +(52223), +(52224), +(52228), +(52229), +(52230), +(52251), +(52252), +(52253), +(52256), +(52261), +(52263), +(52265), +(52267), +(52270), +(52280), +(52282), +(52292), +(52307), +(52312), +(52318), +(52327), +(52328), +(52334), +(52345), +(52346), +(52352), +(52353), +(52355), +(52356), +(52359), +(52360), +(52361), +(52364), +(52372), +(52373), +(52374), +(52375), +(52383), +(52389), +(52391), +(52401), +(52402), +(52415), +(52425), +(52428), +(52430), +(52431), +(52433), +(52444), +(52445), +(52447), +(52460), +(52463), +(52465), +(52466), +(52468), +(52469), +(52471), +(52472), +(52473), +(52474), +(52475), +(52476), +(52486), +(52487), +(52496), +(52498), +(52499), +(52501), +(52502), +(52504), +(52506), +(52511), +(52515), +(52519), +(52521), +(52522), +(52527), +(52532), +(52534), +(52536), +(52537), +(52538), +(52540), +(52542), +(52544), +(52545), +(52546), +(52547), +(52548), +(52549), +(52554), +(52566), +(52577), +(52581), +(52583), +(52586), +(52587), +(52591), +(52594), +(52595), +(52596), +(52600), +(52601), +(52604), +(52608), +(52609), +(52610), +(52613), +(52620), +(52631), +(52633), +(52643), +(52644), +(52655), +(52657), +(52658), +(52660), +(52672), +(52675), +(52680), +(52684), +(52695), +(52696), +(52699), +(52700), +(52702), +(52705), +(52708), +(52709), +(52711), +(52713), +(52715), +(52718), +(52719), +(52721), +(52722), +(52737), +(52740), +(52741), +(52743), +(52751), +(52752), +(52754), +(52755), +(52758), +(52761), +(52762), +(52764), +(52771), +(52772), +(52773), +(52778), +(52781), +(52782), +(52784), +(52789), +(52794), +(52806), +(52807), +(52813), +(52814), +(52818), +(52825), +(52835), +(52839), +(52851), +(52856), +(52859), +(52862), +(52863), +(52864), +(52871), +(52872), +(52873), +(52883), +(52885), +(52889), +(52890), +(52904), +(52905), +(52909), +(52921), +(52926), +(52931), +(52932), +(52939), +(52943), +(52986), +(52987), +(52988), +(52992), +(52994), +(52996), +(53001), +(53002), +(53003), +(53005), +(53006), +(53007), +(53019), +(53023), +(53027), +(53031), +(53033), +(53043), +(53044), +(53045), +(53051), +(53058), +(53059), +(53060), +(53062), +(53068), +(53069), +(53070), +(53072), +(53073), +(53085), +(53086), +(53087), +(53088), +(53089), +(53094), +(53098), +(53099), +(53100), +(53101), +(53102), +(53108), +(53109), +(53111), +(53116), +(53141), +(53145), +(53148), +(53150), +(53153), +(53158), +(53174), +(53191), +(53193), +(53194), +(53195), +(53208), +(53209), +(53214), +(53254), +(53271), +(53288), +(53289), +(53301), +(53307), +(53308), +(53310), +(53311), +(53313), +(53314), +(53317), +(53318), +(53322), +(53326), +(53327), +(53329), +(53330), +(53332), +(53333), +(53335), +(53338), +(53339), +(53340), +(53346), +(53351), +(53352), +(53353), +(53357), +(53359), +(53364), +(53366), +(53372), +(53388), +(53394), +(53395), +(53396), +(53402), +(53404), +(53407), +(53408), +(53418), +(53422), +(53424), +(53425), +(53431), +(53435), +(53437), +(53438), +(53442), +(53449), +(53460), +(53477), +(53480), +(53492), +(53493), +(53498), +(53499), +(53508), +(53509), +(53526), +(53528), +(53529), +(53532), +(53533), +(53534), +(53536), +(53537), +(53538), +(53540), +(53542), +(53543), +(53544), +(53545), +(53546), +(53547), +(53548), +(53549), +(53550), +(53558), +(53559), +(53560), +(53561), +(53562), +(53564), +(53565), +(53566), +(53567), +(53568), +(53571), +(53572), +(53573), +(53574), +(53575), +(53578), +(53579), +(53580), +(53581), +(53582), +(53584), +(53586), +(53587), +(53588), +(53589), +(53595), +(53600), +(53601), +(53617), +(53618), +(53625), +(53629), +(53631), +(53633), +(53638), +(53639), +(53652), +(53653), +(53654), +(53659), +(53669), +(53697), +(53704), +(53719), +(53726), +(53733), +(53739), +(53742), +(53769), +(53772), +(53786), +(53788), +(53799), +(53807), +(53809), +(53810), +(53815), +(53821), +(53824), +(54016), +(54028), +(54029), +(54035), +(54039), +(54042), +(54049), +(54050), +(54051), +(54052), +(54053), +(54060), +(54063), +(54068), +(54070), +(54071), +(54074), +(54075), +(54076), +(54077), +(54078), +(54079), +(54080), +(54092), +(54094), +(54095), +(54096), +(54113), +(54121), +(54126), +(54129), +(54132), +(54135), +(54158), +(54169), +(54172), +(54175), +(54183), +(54185), +(54188), +(54190), +(54191), +(54195), +(54196), +(54198), +(54203), +(54216), +(54226), +(54235), +(54237), +(54238), +(54249), +(54260), +(54261), +(54273), +(54283), +(54284), +(54290), +(54299), +(54303), +(54309), +(54311), +(54315), +(54316), +(54319), +(54321), +(54324), +(54331), +(54334), +(54335), +(54337), +(54338), +(54339), +(54340), +(54345), +(54350), +(54361), +(54376), +(54378), +(54380), +(54387), +(54393), +(54394), +(54395), +(54396), +(54399), +(54416), +(54417), +(54429), +(54431), +(54433), +(54451), +(54453), +(54458), +(54459), +(54460), +(54468), +(54470), +(54479), +(54485), +(54487), +(54491), +(54495), +(54498), +(54499), +(54502), +(54504), +(54507), +(54511), +(54514), +(54518), +(54521), +(54525), +(54526), +(54527), +(54531), +(54532), +(54540), +(54549), +(54565), +(54573), +(54576), +(54577), +(54578), +(54587), +(54588), +(54593), +(54594), +(54602), +(54604), +(54609), +(54610), +(54611), +(54612), +(54613), +(54615), +(54616), +(54617), +(54618), +(54619), +(54620), +(54622), +(54624), +(54630), +(54631), +(54632), +(54634), +(54640), +(54644), +(54646), +(54648), +(54651), +(54660), +(54662), +(54663), +(54667), +(54668), +(54673), +(54675), +(54677), +(54679), +(54680), +(54688), +(54689), +(54694), +(54702), +(54703), +(54704), +(54706), +(54708), +(54709), +(54716), +(54719), +(54723), +(54755), +(54757), +(54761), +(54770), +(54772), +(54781), +(54785), +(54788), +(54790), +(54791), +(54794), +(54799), +(54801), +(54804), +(54805), +(54820), +(54822), +(54823), +(54843), +(54846), +(54880), +(54881), +(54882), +(54883), +(54884), +(54885), +(54886), +(54887), +(54900), +(54906), +(54908), +(54919), +(54920), +(54932), +(54933), +(54951), +(54956), +(54957), +(54958), +(54965), +(54970), +(54971), +(54973), +(54974), +(54975), +(54976), +(54977), +(54982), +(54983), +(54986), +(54987), +(54992), +(54997), +(55006), +(55007), +(55008), +(55009), +(55021), +(55029), +(55039), +(55041), +(55046), +(55050), +(55051), +(55054), +(55065), +(55066), +(55069), +(55070), +(55071), +(55074), +(55075), +(55078), +(55079), +(55090), +(55093), +(55095), +(55102), +(55104), +(55144), +(55160), +(55168), +(55196), +(55209), +(55210), +(55216), +(55217), +(55218), +(55219), +(55220), +(55224), +(55225), +(55226), +(55240), +(55241), +(55253), +(55255), +(55258), +(55259), +(55260), +(55261), +(55262), +(55263), +(55264), +(55265), +(55268), +(55269), +(55270), +(55271), +(55274), +(55276), +(55277), +(55281), +(55284), +(55313), +(55314), +(55317), +(55318), +(55319), +(55320), +(55321), +(55322), +(55324), +(55331), +(55334), +(55346), +(55348), +(55359), +(55360), +(55363), +(55364), +(55411), +(55412), +(55416), +(55424), +(55425), +(55430), +(55469), +(55470), +(55482), +(55483), +(55484), +(55485), +(55487), +(55488), +(55489), +(55490), +(55491), +(55492), +(55495), +(55496), +(55497), +(55498), +(55499), +(55504), +(55505), +(55506), +(55507), +(55508), +(55509), +(55511), +(55520), +(55521), +(55530), +(55536), +(55549), +(55550), +(55555), +(55556), +(55557), +(55567), +(55568), +(55569), +(55579), +(55581), +(55582), +(55597), +(55598), +(55599), +(55602), +(55604), +(55605), +(55613), +(55622), +(55624), +(55625), +(55643), +(55645), +(55646), +(55648), +(55652), +(55659), +(55700), +(55703), +(55704), +(55716), +(55719), +(55728), +(55736), +(55748), +(55749), +(55750), +(55751), +(55752), +(55753), +(55754), +(55756), +(55770), +(55771), +(55772), +(55778), +(55779), +(55780), +(55781), +(55790), +(55797), +(55802), +(55804), +(55809), +(55813), +(55815), +(55818), +(55823), +(55824), +(55838), +(55840), +(55841), +(55864), +(55874), +(55877), +(55880), +(55890), +(55894), +(55929), +(55931), +(55932), +(55933), +(55935), +(55936), +(55937), +(55939), +(55951), +(55958), +(55959), +(55960), +(55962), +(55963), +(55968), +(55973), +(55978), +(55981), +(55982), +(55983), +(55984), +(56033), +(56036), +(56038), +(56046), +(56061), +(56071), +(56072), +(56090), +(56091), +(56092), +(56098), +(56104), +(56106), +(56107), +(56112), +(56113), +(56115), +(56122), +(56123), +(56125), +(56127), +(56130), +(56131), +(56132), +(56138), +(56139), +(56141), +(56143), +(56144), +(56147), +(56149), +(56160), +(56161), +(56185), +(56190), +(56191), +(56198), +(56200), +(56211), +(56222), +(56223), +(56230), +(56236), +(56239), +(56252), +(56254), +(56260), +(56277), +(56287), +(56305), +(56320), +(56326), +(56329), +(56331), +(56332), +(56346), +(56351), +(56352), +(56361), +(56362), +(56379), +(56404), +(56405), +(56411), +(56425), +(56426), +(56430), +(56433), +(56434), +(56440), +(56442), +(56444), +(56447), +(56448), +(56485), +(56491), +(56506), +(56513), +(56515), +(56517), +(56520), +(56521), +(56525), +(56536), +(56537), +(56539), +(56545), +(56557), +(56559), +(56562), +(56564), +(56565), +(56581), +(56582), +(56584), +(56586), +(56603), +(56605), +(56606), +(56607), +(56609), +(56624), +(56626), +(56627), +(56628), +(56629), +(56630), +(56631), +(56640), +(56641), +(56645), +(56659), +(56662), +(56664), +(56666), +(56668), +(56670), +(56671), +(56672), +(56678), +(56685), +(56687), +(56698), +(56699), +(56701), +(56707), +(56715), +(56718), +(56719), +(56720), +(56721), +(56727), +(56728), +(56729), +(56730), +(56731), +(56734), +(56753), +(56754), +(56755), +(56760), +(56761), +(56770), +(56771), +(56772), +(56773), +(56774), +(56775), +(56776), +(56777), +(56780), +(56781), +(56785), +(56790), +(56791), +(56795), +(56796), +(56797), +(56815), +(56854), +(56860), +(56861), +(56862), +(56891), +(56893), +(56896), +(56898), +(56902), +(56903), +(56905), +(56906), +(56907), +(56909), +(56917), +(56918), +(56919), +(56920), +(56921), +(56922), +(56923), +(56925), +(56933), +(56937), +(56938), +(56939), +(56940), +(56966), +(56969), +(57049), +(57050), +(57052), +(57053), +(57058), +(57062), +(57063), +(57089), +(57090), +(57094), +(57095), +(57108), +(57118), +(57143), +(57292), +(57305), +(57323), +(57337), +(57346), +(57347), +(57369), +(57374), +(57376), +(57380), +(57384), +(57386), +(57388), +(57389), +(57390), +(57391), +(57392), +(57393), +(57395), +(57397), +(57402), +(57407), +(57411), +(57413), +(57420), +(57454), +(57456), +(57461), +(57464), +(57465), +(57466), +(57473), +(57480), +(57486), +(57487), +(57488), +(57490), +(57506), +(57507), +(57528), +(57530), +(57536), +(57537), +(57547), +(57548), +(57553), +(57554), +(57556), +(57573), +(57580), +(57582), +(57587), +(57589), +(57590), +(57593), +(57594), +(57596), +(57599), +(57601), +(57602), +(57603), +(57615), +(57616), +(57617), +(57620), +(57628), +(57635), +(57640), +(57641), +(57644), +(57645), +(57647), +(57648), +(57651), +(57657), +(57661), +(57665), +(57670), +(57671), +(57677), +(57679), +(57723), +(57724), +(57725), +(57745), +(57755), +(57759), +(57765), +(57766), +(57767), +(57770), +(57774), +(57775), +(57777), +(57778), +(57779), +(57780), +(57781), +(57783), +(57785), +(57787), +(57789), +(57790), +(57795), +(57799), +(57802), +(57807), +(57808), +(57823), +(57825), +(57833), +(57834), +(57838), +(57841), +(57842), +(57845), +(57846), +(57860), +(57863), +(57864), +(57871), +(57874), +(57888), +(57896), +(57897), +(57906), +(57908), +(57914), +(57921), +(57922), +(57941), +(57949), +(57951), +(57964), +(57965), +(57969), +(57970), +(57974), +(57975), +(57981), +(57984), +(57992), +(57993), +(57994), +(58012), +(58021), +(58025), +(58044), +(58054), +(58061), +(58062), +(58071), +(58106), +(58117), +(58118), +(58119), +(58151), +(58154), +(58179), +(58180), +(58181), +(58183), +(58184), +(58187), +(58194), +(58203), +(58204), +(58205), +(58207), +(58208), +(58209), +(58210), +(58211), +(58212), +(58213), +(58214), +(58215), +(58216), +(58217), +(58218), +(58219), +(58220), +(58221), +(58222), +(58223), +(58224), +(58230), +(58270), +(58282), +(58283), +(58349), +(58351), +(58352), +(58371), +(58373), +(58412), +(58418), +(58419), +(58420), +(58421), +(58438), +(58448), +(58449), +(58450), +(58451), +(58452), +(58453), +(58456), +(58457), +(58459), +(58460), +(58461), +(58462), +(58464), +(58466), +(58471), +(58475), +(58494), +(58504), +(58505), +(58508), +(58509), +(58510), +(58511), +(58513), +(58514), +(58516), +(58517), +(58518), +(58519), +(58520), +(58526), +(58529), +(58531), +(58534), +(58535), +(58537), +(58544), +(58548), +(58561), +(58563), +(58564), +(58566), +(58567), +(58597), +(58604), +(58605), +(58607), +(58608), +(58609), +(58610), +(58611), +(58612), +(58617), +(58619), +(58621), +(58622), +(58624), +(58628), +(58632), +(58633), +(58642), +(58644), +(58660), +(58663), +(58664), +(58665), +(58666), +(58667), +(58678), +(58681), +(58683), +(58684), +(58691), +(58700), +(58701), +(58702), +(58743), +(58747), +(58758), +(58769), +(58770), +(58772), +(58781), +(58782), +(58786), +(58787), +(58788), +(58797), +(58798), +(58799), +(58810), +(58811), +(58814), +(58815), +(58816), +(58817), +(58822), +(58823), +(58827), +(58829), +(58830), +(58839), +(58840), +(58843), +(58844), +(58845), +(58847), +(58849), +(58850), +(58855), +(58859), +(58861), +(58867), +(58879), +(58890), +(58896), +(58898), +(58902), +(58905), +(58912), +(58913), +(58915), +(58919), +(58921), +(58922), +(58935), +(58940), +(58941), +(58953), +(58955), +(58959), +(58961), +(58966), +(58967), +(58969), +(58971), +(58972), +(58973), +(58976), +(58978), +(58980), +(58981), +(58987), +(58988), +(58989), +(58991), +(58996), +(59001), +(59006), +(59007), +(59011), +(59013), +(59016), +(59017), +(59019), +(59020), +(59021), +(59023), +(59024), +(59025), +(59034), +(59035), +(59039), +(59040), +(59044), +(59047), +(59050), +(59051), +(59060), +(59064), +(59065), +(59069), +(59079), +(59080), +(59081), +(59082), +(59083), +(59085), +(59100), +(59102), +(59104), +(59105), +(59106), +(59109), +(59110), +(59111), +(59114), +(59119), +(59121), +(59124), +(59130), +(59131), +(59132), +(59133), +(59134), +(59138), +(59142), +(59144), +(59146), +(59147), +(59148), +(59150), +(59151), +(59153), +(59155), +(59160), +(59161), +(59163), +(59164), +(59165), +(59166), +(59167), +(59168), +(59169), +(59170), +(59171), +(59172), +(59178), +(59179), +(59180), +(59182), +(59185), +(59186), +(59187), +(59191), +(59192), +(59199), +(59209), +(59210), +(59211), +(59215), +(59220), +(59223), +(59225), +(59226), +(59228), +(59233), +(59235), +(59237), +(59239), +(59241), +(59242), +(59243), +(59244), +(59246), +(59247), +(59248), +(59249), +(59251), +(59252), +(59254), +(59256), +(59257), +(59259), +(59260), +(59261), +(59262), +(59263), +(59264), +(59265), +(59268), +(59269), +(59270), +(59271), +(59273), +(59280), +(59288), +(59290), +(59300), +(59304), +(59318), +(59319), +(59324), +(59325), +(59329), +(59330), +(59331), +(59342), +(59343), +(59344), +(59346), +(59347), +(59348), +(59350), +(59351), +(59352), +(59355), +(59357), +(59359), +(59361), +(59362), +(59364), +(59367), +(59371), +(59373), +(59374), +(59376), +(59381), +(59389), +(59391), +(59392), +(59395), +(59397), +(59398), +(59399), +(59400), +(59401), +(59402), +(59408), +(59409), +(59412), +(59413), +(59423), +(59432), +(59434), +(59439), +(59444), +(59448), +(59455), +(59460), +(59467), +(59468), +(59471), +(59482), +(59485), +(59513), +(59515), +(59517), +(59519), +(59520), +(59525), +(59530), +(59542), +(59543), +(59544), +(59545), +(59547), +(59548), +(59557), +(59558), +(59563), +(59575), +(59577), +(59590), +(59593), +(59594), +(59599), +(59603), +(59604), +(59605), +(59606), +(59607), +(59608), +(59610), +(59611), +(59616), +(59617), +(59633), +(59634), +(59637), +(59638), +(59651), +(59653), +(59656), +(59661), +(59663), +(59679), +(59682), +(59683), +(59684), +(59685), +(59691), +(59695), +(59696), +(59700), +(59703), +(59710), +(59712), +(59713), +(59715), +(59716), +(59717), +(59718), +(59723), +(59727), +(59735), +(59736), +(59742), +(59743), +(59746), +(59750), +(59760), +(59762), +(59763), +(59765), +(59766), +(59767), +(59769), +(59779), +(59795), +(59805), +(59812), +(59813), +(59814), +(59815), +(59817), +(59823), +(59826), +(59827), +(59832), +(59839), +(59840), +(59841), +(59844), +(59846), +(59851), +(59852), +(59855), +(59856), +(59863), +(59864), +(59877), +(59879), +(59881), +(59882), +(59883), +(59884), +(59885), +(59886), +(59894), +(59901), +(59921), +(59963), +(59965), +(59972), +(59974), +(59978), +(59982), +(59984), +(59985), +(59986), +(59987), +(59988), +(59989), +(59991), +(59992), +(59993), +(59994), +(59997), +(59999), +(60003), +(60004), +(60005), +(60006), +(60008), +(60009), +(60011), +(60012), +(60013), +(60015), +(60016), +(60017), +(60018), +(60032), +(60035), +(60039), +(60041), +(60043), +(60051), +(60052), +(60053), +(60067), +(60073), +(60076), +(60078), +(60079), +(60080), +(60085), +(60089), +(60100), +(60103), +(60106), +(60107), +(60111), +(60112), +(60115), +(60117), +(60122), +(60123), +(60127), +(60129), +(60181), +(60183), +(60186), +(60194), +(60195), +(60197), +(60203), +(60204), +(60210), +(60211), +(60212), +(60229), +(60233), +(60234), +(60235), +(60236), +(60239), +(60241), +(60300), +(60307), +(60309), +(60339), +(60351), +(60352), +(60428), +(60431), +(60432), +(60433), +(60440), +(60443), +(60446), +(60447), +(60450), +(60452), +(60453), +(60472), +(60474), +(60483), +(60488), +(60500), +(60504), +(60505), +(60506), +(60518), +(60526), +(60530), +(60540), +(60541), +(60542), +(60578), +(60580), +(60585), +(60588), +(60590), +(60626), +(60642), +(60644), +(60646), +(60654), +(60672), +(60678), +(60682), +(60683), +(60699), +(60708), +(60742), +(60753), +(60781), +(60782), +(60784), +(60785), +(60786), +(60790), +(60802), +(60803), +(60805), +(60809), +(60814), +(60817), +(60842), +(60844), +(60850), +(60856), +(60857), +(60859), +(60868), +(60869), +(60870), +(60871), +(60872), +(60873), +(60876), +(60880), +(60882), +(60890), +(60896), +(60897), +(60898), +(60899), +(60900), +(60901), +(60905), +(60906), +(60917), +(60918), +(60924), +(60926), +(60927), +(60930), +(60932), +(60935), +(60940), +(60941), +(60944), +(60945), +(60946), +(60947), +(60949), +(60950), +(60951), +(60952), +(60954), +(60959), +(60961), +(60962), +(60963), +(60965), +(60968), +(60972), +(60973), +(60979), +(60980), +(60981), +(60982), +(60983), +(60988), +(60991), +(60995), +(61001), +(61005), +(61006), +(61016), +(61018), +(61024), +(61025), +(61029), +(61034), +(61036), +(61039), +(61041), +(61042), +(61046), +(61048), +(61051), +(61064), +(61070), +(61077), +(61080), +(61083), +(61087), +(61091), +(61094), +(61100), +(61101), +(61103), +(61109), +(61110), +(61111), +(61115), +(61123), +(61124), +(61127), +(61129), +(61133), +(61140), +(61143), +(61159), +(61160), +(61162), +(61164), +(61166), +(61168), +(61171), +(61172), +(61173), +(61176), +(61178), +(61182), +(61186), +(61187), +(61191), +(61193), +(61194), +(61195), +(61196), +(61197), +(61198), +(61209), +(61211), +(61213), +(61215), +(61218), +(61223), +(61226), +(61242), +(61243), +(61244), +(61253), +(61259), +(61260), +(61263), +(61269), +(61272), +(61281), +(61282), +(61286), +(61287), +(61291), +(61295), +(61296), +(61299), +(61300), +(61301), +(61302), +(61305), +(61314), +(61319), +(61320), +(61326), +(61327), +(61343), +(61344), +(61347), +(61352), +(61358), +(61372), +(61373), +(61374), +(61375), +(61380), +(61381), +(61382), +(61385), +(61395), +(61398), +(61399), +(61409), +(61411), +(61415), +(61419), +(61420), +(61421), +(61423), +(61424), +(61443), +(61445), +(61448), +(61454), +(61457), +(61461), +(61466), +(61474), +(61479), +(61480), +(61486), +(61490), +(61491), +(61493), +(61507), +(61511), +(61512), +(61515), +(61528), +(61545), +(61549), +(61550), +(61552), +(61554), +(61556), +(61558), +(61561), +(61562), +(61563), +(61565), +(61567), +(61569), +(61572), +(61579), +(61584), +(61590), +(61592), +(61593), +(61596), +(61597), +(61599), +(61600), +(61601), +(61604), +(61606), +(61607), +(61613), +(61621), +(61623), +(61624), +(61626), +(61627), +(61628), +(61634), +(61635), +(61662), +(61663), +(61666), +(61667), +(61668), +(61676), +(61685), +(61696), +(61705), +(61712), +(61716), +(61721), +(61728), +(61729), +(61730), +(61733), +(61747), +(61767), +(61780), +(61781), +(61789), +(61791), +(61793), +(61794), +(61795), +(61796), +(61797), +(61798), +(61799), +(61800), +(61801), +(61802), +(61804), +(61805), +(61806), +(61807), +(61808), +(61815), +(61817), +(61819), +(61821), +(61822), +(61823), +(61824), +(61825), +(61832), +(61833), +(61834), +(61835), +(61836), +(61837), +(61838), +(61839), +(61840), +(61841), +(61842), +(61843), +(61844), +(61845), +(61849), +(61857), +(61859), +(61862), +(61866), +(61868), +(61870), +(61873), +(61879), +(61880), +(61881), +(61888), +(61893), +(61895), +(61896), +(61897), +(61903), +(61909), +(61911), +(61912), +(61923), +(61924), +(61925), +(61926), +(61927), +(61928), +(61929), +(61965), +(61967), +(61973), +(61998), +(62014), +(62026), +(62030), +(62036), +(62053), +(62063), +(62078), +(62089), +(62103), +(62105), +(62117), +(62118), +(62119), +(62120), +(62121), +(62122), +(62124), +(62128), +(62129), +(62130), +(62131), +(62138), +(62167), +(62169), +(62195), +(62198), +(62204), +(62225), +(62226), +(62249), +(62250), +(62261), +(62264), +(62265), +(62280), +(62292), +(62298), +(62305), +(62309), +(62310), +(62312), +(62315), +(62316), +(62317), +(62318), +(62322), +(62326), +(62327), +(62328), +(62331), +(62332), +(62333), +(62334), +(62335), +(62342), +(62347), +(62354), +(62356), +(62368), +(62372), +(62373), +(62382), +(62395), +(62401), +(62402), +(62415), +(62417), +(62418), +(62420), +(62441), +(62442), +(62443), +(62444), +(62445), +(62446), +(62455), +(62456), +(62466), +(62479), +(62482), +(62503), +(62507), +(62526), +(62531), +(62536), +(62540), +(62544), +(62554), +(62563), +(62575), +(62581), +(62583), +(62589), +(62601), +(62607), +(62608), +(62611), +(62613), +(62614), +(62626), +(62638), +(62648), +(62649), +(62653), +(62658), +(62672), +(62673), +(62707), +(62708), +(62711), +(62717), +(62722), +(62726), +(62732), +(62767), +(62768), +(62769), +(62793), +(62796), +(62806), +(62832), +(62836), +(62844), +(62845), +(62846), +(62854), +(62855), +(62863), +(62867), +(62874), +(62875), +(62881), +(62900), +(62901), +(62902), +(62903), +(62904), +(62928), +(62935), +(62938), +(62939), +(62960), +(62961), +(62989), +(62997), +(62998), +(63003), +(63010), +(63012), +(63028), +(63034), +(63035), +(63036), +(63047), +(63082), +(63094), +(63103), +(63104), +(63105), +(63111), +(63112), +(63120), +(63124), +(63125), +(63126), +(63127), +(63134), +(63136), +(63138), +(63147), +(63151), +(63169), +(63171), +(63172), +(63174), +(63175), +(63177), +(63178), +(63179), +(63180), +(63183), +(63184), +(63185), +(63216), +(63221), +(63226), +(63228), +(63233), +(63240), +(63242), +(63259), +(63276), +(63278), +(63301), +(63311), +(63313), +(63314), +(63315), +(63316), +(63336), +(63337), +(63338), +(63344), +(63345), +(63356), +(63359), +(63361), +(63362), +(63363), +(63380), +(63382), +(63413), +(63416), +(63418), +(63459), +(63462), +(63463), +(63464), +(63465), +(63466), +(63468), +(63477), +(63479), +(63487), +(63493), +(63494), +(63495), +(63511), +(63518), +(63519), +(63529), +(63535), +(63536), +(63544), +(63549), +(63550), +(63551), +(63553), +(63556), +(63559), +(63562), +(63564), +(63569), +(63571), +(63573), +(63575), +(63599), +(63605), +(63612), +(63615), +(63619), +(63652), +(63653), +(63654), +(63655), +(63661), +(63668), +(63669), +(63670), +(63671), +(63672), +(63673), +(63675), +(63678), +(63685), +(63689), +(63691), +(63699), +(63700), +(63716), +(63728), +(63736), +(63738), +(63754), +(63755), +(63759), +(63760), +(63789), +(63803), +(63804), +(63809), +(63815), +(63823), +(63825), +(63827), +(63845), +(63846), +(63852), +(63861), +(63913), +(63914), +(63915), +(63916), +(63917), +(63918), +(63919), +(63920), +(63921), +(63922), +(63923), +(63931), +(63980), +(63989), +(63993), +(63995), +(63997), +(63998), +(64003), +(64005), +(64006), +(64014), +(64024), +(64025), +(64026), +(64027), +(64028), +(64029), +(64030), +(64031), +(64032), +(64034), +(64036), +(64039), +(64044), +(64058), +(64065), +(64085), +(64090), +(64097), +(64102), +(64104), +(64107), +(64113), +(64114), +(64115), +(64119), +(64123), +(64128), +(64134), +(64136), +(64138), +(64142), +(64151), +(64152), +(64153), +(64156), +(64157), +(64159), +(64160), +(64186), +(64204), +(64211), +(64212), +(64213), +(64215), +(64230), +(64269), +(64324), +(64328), +(64330), +(64331), +(64332), +(64333), +(64334), +(64335), +(64336), +(64337), +(64338), +(64339), +(64342), +(64346), +(64363), +(64365), +(64367), +(64374), +(64375), +(64376), +(64377), +(64380), +(64382), +(64387), +(64388), +(64390), +(64391), +(64395), +(64396), +(64412), +(64413), +(64429), +(64430), +(64442), +(64467), +(64478), +(64496), +(64499), +(64501), +(64507), +(64528), +(64529), +(64535), +(64542), +(64552), +(64580), +(64583), +(64588), +(64590), +(64591), +(64592), +(64595), +(64627), +(64637), +(64638), +(64640), +(64646), +(64647), +(64648), +(64649), +(64654), +(64665), +(64666), +(64667), +(64668), +(64669), +(64674), +(64682), +(64686), +(64692), +(64696), +(64698), +(64699), +(64705), +(64719), +(64740), +(64757), +(64758), +(64759), +(64766), +(64768), +(64771), +(64773), +(64776), +(64780), +(64787), +(64795), +(64798), +(64801), +(64806), +(64807), +(64821), +(64841), +(64870), +(64874), +(64876), +(64888), +(64891), +(64903), +(64909), +(64918), +(64930), +(64953), +(64967), +(64970), +(64971), +(64974), +(64978), +(64991), +(65030), +(65031), +(65033), +(65035), +(65036), +(65038), +(65039), +(65040), +(65042), +(65054), +(65055), +(65056), +(65057), +(65058), +(65059), +(65061), +(65062), +(65071), +(65080), +(65081), +(65104), +(65111), +(65113), +(65122), +(65123), +(65131), +(65133), +(65147), +(65162), +(65201), +(65210), +(65240), +(65266), +(65280), +(65343), +(65351), +(65359), +(65360), +(65374), +(65378), +(65379), +(65386), +(65391), +(65392), +(65403), +(65431), +(65488), +(65490), +(65492), +(65502), +(65503), +(65512), +(65513), +(65516), +(65531), +(65532), +(65541), +(65542), +(65545), +(65546), +(65564), +(65565), +(65575), +(65576), +(65577), +(65634), +(65635), +(65636), +(65647), +(65648), +(65693), +(65694), +(65703), +(65720), +(65722), +(65723), +(65728), +(65729), +(65744), +(65754), +(65775), +(65778), +(65782), +(65790), +(65791), +(65799), +(65801), +(65807), +(65809), +(65810), +(65812), +(65813), +(65814), +(65815), +(65819), +(65820), +(65821), +(65825), +(65826), +(65854), +(65855), +(65856), +(65857), +(65859), +(65862), +(65863), +(65866), +(65867), +(65868), +(65877), +(65878), +(65881), +(65883), +(65918), +(65924), +(65926), +(65927), +(65929), +(65930), +(65931), +(65934), +(65935), +(65936), +(65940), +(65941), +(65954), +(65957), +(65960), +(65962), +(65970), +(65971), +(65972), +(65973), +(65974), +(65978), +(65987), +(65998), +(66003), +(66005), +(66007), +(66008), +(66009), +(66012), +(66017), +(66018), +(66019), +(66020), +(66021), +(66042), +(66043), +(66045), +(66047), +(66053), +(66054), +(66055), +(66056), +(66057), +(66063), +(66065), +(66066), +(66067), +(66068), +(66069), +(66070), +(66072), +(66075), +(66079), +(66081), +(66093), +(66095), +(66097), +(66099), +(66100), +(66104), +(66109), +(66112), +(66113), +(66114), +(66115), +(66116), +(66125), +(66126), +(66134), +(66154), +(66177), +(66188), +(66196), +(66197), +(66198), +(66206), +(66207), +(66209), +(66213), +(66215), +(66216), +(66217), +(66236), +(66237), +(66240), +(66243), +(66244), +(66245), +(66250), +(66259), +(66260), +(66261), +(66262), +(66265), +(66283), +(66285), +(66290), +(66291), +(66292), +(66293), +(66294), +(66295), +(66313), +(66326), +(66331), +(66334), +(66342), +(66359), +(66377), +(66378), +(66407), +(66408), +(66409), +(66410), +(66417), +(66420), +(66423), +(66425), +(66457), +(66460), +(66461), +(66474), +(66477), +(66479), +(66480), +(66481), +(66489), +(66493), +(66516), +(66528), +(66532), +(66533), +(66536), +(66537), +(66538), +(66548), +(66549), +(66588), +(66592), +(66593), +(66594), +(66595), +(66596), +(66613), +(66619), +(66620), +(66629), +(66638), +(66666), +(66668), +(66669), +(66686), +(66687), +(66688), +(66689), +(66716), +(66717), +(66719), +(66733), +(66735), +(66736), +(66742), +(66744), +(66765), +(66770), +(66773), +(66777), +(66784), +(66796), +(66797), +(66809), +(66813), +(66823), +(66824), +(66863), +(66867), +(66869), +(66879), +(66880), +(66887), +(66888), +(66890), +(66891), +(66892), +(66899), +(66903), +(66904), +(66922), +(66940), +(66941), +(66950), +(66951), +(66952), +(66953), +(66954), +(66955), +(66957), +(66958), +(66959), +(66960), +(66961), +(66962), +(66963), +(66964), +(66965), +(66972), +(66973), +(66974), +(66975), +(66976), +(66977), +(66978), +(66979), +(66988), +(66989), +(66990), +(66991), +(66992), +(66994), +(67029), +(67030), +(67031), +(67033), +(67035), +(67049), +(67050), +(67051), +(67073), +(67074), +(67075), +(67088), +(67089), +(67090), +(67097), +(67098), +(67099), +(67114), +(67148), +(67229), +(67235), +(67237), +(67247), +(67252), +(67253), +(67280), +(67289), +(67290), +(67309), +(67310), +(67311), +(67312), +(67313), +(67314), +(67324), +(67325), +(67330), +(67331), +(67333), +(67366), +(67372), +(67373), +(67387), +(67390), +(67477), +(67478), +(67479), +(67480), +(67481), +(67485), +(67518), +(67519), +(67528), +(67529), +(67530), +(67531), +(67532), +(67533), +(67534), +(67540), +(67542), +(67550), +(67554), +(67560), +(67573), +(67574), +(67577), +(67606), +(67607), +(67608), +(67612), +(67613), +(67614), +(67618), +(67619), +(67620), +(67624), +(67625), +(67626), +(67632), +(67633), +(67634), +(67650), +(67651), +(67652), +(67654), +(67655), +(67656), +(67674), +(67675), +(67676), +(67678), +(67679), +(67680), +(67686), +(67703), +(67708), +(67709), +(67710), +(67714), +(67718), +(67719), +(67721), +(67722), +(67724), +(67725), +(67730), +(67745), +(67749), +(67760), +(67767), +(67772), +(67773), +(67774), +(67793), +(67799), +(67810), +(67811), +(67817), +(67818), +(67819), +(67821), +(67823), +(67830), +(67834), +(67835), +(67836), +(67837), +(67838), +(67846), +(67847), +(67861), +(67862), +(67863), +(67878), +(67879), +(67880), +(67881), +(67882), +(67883), +(67884), +(67885), +(67891), +(67892), +(67905), +(67906), +(67907), +(67929), +(67930), +(67931), +(67932), +(67933), +(67934), +(67935), +(67936), +(67937), +(67938), +(67939), +(67940), +(67941), +(67942), +(67943), +(67944), +(67945), +(67946), +(67947), +(67948), +(67949), +(67951), +(67952), +(67953), +(67957), +(67958), +(67959), +(67965), +(67966), +(67967), +(67968), +(67969), +(67970), +(67971), +(67972), +(67973), +(67977), +(67978), +(67979), +(67980), +(67981), +(67982), +(67983), +(67984), +(67985), +(67988), +(67989), +(67990), +(67991), +(67992), +(67993), +(67994), +(67995), +(67996), +(67997), +(67998), +(67999), +(68003), +(68004), +(68005), +(68008), +(68009), +(68010), +(68011), +(68012), +(68013), +(68014), +(68015), +(68016), +(68017), +(68018), +(68019), +(68023), +(68024), +(68025), +(68026), +(68027), +(68028), +(68032), +(68033), +(68034), +(68035), +(68036), +(68037), +(68038), +(68039), +(68040), +(68042), +(68043), +(68044), +(68055), +(68073), +(68077), +(68078), +(68081), +(68088), +(68089), +(68090), +(68091), +(68092), +(68093), +(68094), +(68095), +(68096), +(68100), +(68101), +(68102), +(68106), +(68107), +(68108), +(68109), +(68110), +(68111), +(68112), +(68113), +(68114), +(68115), +(68116), +(68117), +(68118), +(68119), +(68120), +(68123), +(68124), +(68125), +(68130), +(68133), +(68134), +(68135), +(68136), +(68137), +(68138), +(68139), +(68140), +(68141), +(68148), +(68149), +(68150), +(68151), +(68152), +(68153), +(68154), +(68155), +(68156), +(68157), +(68158), +(68159), +(68272), +(68282), +(68284), +(68301), +(68306), +(68307), +(68310), +(68311), +(68313), +(68315), +(68317), +(68318), +(68319), +(68321), +(68328), +(68333), +(68334), +(68340), +(68341), +(68350), +(68357), +(68362), +(68363), +(68364), +(68365), +(68372), +(68391), +(68415), +(68458), +(68472), +(68478), +(68479), +(68498), +(68501), +(68502), +(68503), +(68504), +(68505), +(68550), +(68551), +(68586), +(68587), +(68588), +(68607), +(68621), +(68622), +(68623), +(68624), +(68625), +(68626), +(68627), +(68628), +(68629), +(68727), +(68753), +(68754), +(68755), +(68756), +(68757), +(68758), +(68762), +(68763), +(68764), +(68778), +(68781), +(68782), +(68783), +(68784), +(68788), +(68799), +(68812), +(68834), +(68839), +(68841), +(68843), +(68868), +(68879), +(68884), +(68900), +(68915), +(68927), +(68934), +(68948), +(68966), +(68971), +(68980), +(68982), +(68984), +(68985), +(68991), +(69000), +(69003), +(69021), +(69023), +(69028), +(69034), +(69038), +(69051), +(69058), +(69063), +(69065), +(69066), +(69067), +(69068), +(69088), +(69091), +(69124), +(69128), +(69130), +(69131), +(69133), +(69137), +(69138), +(69153), +(69155), +(69156), +(69158), +(69160), +(69172), +(69180), +(69181), +(69189), +(69190), +(69198), +(69200), +(69209), +(69210), +(69211), +(69212), +(69218), +(69222), +(69232), +(69243), +(69246), +(69274), +(69275), +(69276), +(69285), +(69308), +(69342), +(69352), +(69387), +(69389), +(69391), +(69397), +(69398), +(69403), +(69404), +(69405), +(69406), +(69409), +(69410), +(69416), +(69420), +(69427), +(69438), +(69445), +(69455), +(69483), +(69489), +(69492), +(69496), +(69497), +(69498), +(69499), +(69500), +(69501), +(69503), +(69504), +(69520), +(69528), +(69542), +(69543), +(69544), +(69548), +(69563), +(69564), +(69566), +(69567), +(69569), +(69570), +(69572), +(69573), +(69574), +(69576), +(69577), +(69578), +(69579), +(69581), +(69583), +(69603), +(69617), +(69623), +(69627), +(69633), +(69644), +(69651), +(69668), +(69672), +(69673), +(69675), +(69681), +(69692), +(69693), +(69696), +(69699), +(69710), +(69722), +(69724), +(69726), +(69729), +(69730), +(69731), +(69733), +(69734), +(69771), +(69772), +(69779), +(69828), +(69837), +(69856), +(69861), +(69866), +(69869), +(69871), +(69882), +(69889), +(69891), +(69892), +(69893), +(69896), +(69898), +(69899), +(69902), +(69903), +(69906), +(69910), +(69911), +(69912), +(69916), +(69917), +(69920), +(69923), +(69926), +(69927), +(69933), +(69956), +(69958), +(69961), +(69963), +(69967), +(69968), +(69969), +(69970), +(69972), +(69973), +(69974), +(69975), +(69984), +(69989), +(70002), +(70043), +(70070), +(70074), +(70080), +(70110), +(70119), +(70122), +(70126), +(70141), +(70144), +(70153), +(70161), +(70162), +(70182), +(70183), +(70191), +(70192), +(70196), +(70205), +(70208), +(70211), +(70213), +(70227), +(70269), +(70270), +(70271), +(70273), +(70275), +(70276), +(70277), +(70278), +(70279), +(70280), +(70281), +(70282), +(70285), +(70289), +(70292), +(70296), +(70302), +(70304), +(70308), +(70309), +(70320), +(70322), +(70327), +(70333), +(70337), +(70355), +(70361), +(70381), +(70386), +(70387), +(70388), +(70391), +(70393), +(70396), +(70400), +(70408), +(70409), +(70410), +(70423), +(70428), +(70429), +(70432), +(70435), +(70437), +(70445), +(70449), +(70451), +(70453), +(70495), +(70510), +(70516), +(70525), +(70538), +(70539), +(70540), +(70542), +(70583), +(70594), +(70599), +(70616), +(70639), +(70640), +(70645), +(70646), +(70648), +(70653), +(70656), +(70659), +(70698), +(70746), +(70751), +(70754), +(70772), +(70781), +(70802), +(70809), +(70821), +(70838), +(70856), +(70857), +(70858), +(70859), +(70860), +(70861), +(70864), +(70867), +(70886), +(70890), +(70895), +(70896), +(70897), +(70906), +(70917), +(70923), +(70928), +(70929), +(70942), +(70946), +(70964), +(70965), +(70971), +(70972), +(70973), +(70974), +(70980), +(71003), +(71004), +(71005), +(71006), +(71020), +(71021), +(71023), +(71038), +(71040), +(71041), +(71087), +(71089), +(71090), +(71103), +(71107), +(71108), +(71112), +(71116), +(71117), +(71119), +(71120), +(71121), +(71124), +(71126), +(71127), +(71129), +(71130), +(71131), +(71133), +(71135), +(71136), +(71138), +(71140), +(71141), +(71142), +(71143), +(71144), +(71145), +(71146), +(71148), +(71153), +(71154), +(71155), +(71157), +(71163), +(71164), +(71169), +(71203), +(71204), +(71237), +(71248), +(71253), +(71254), +(71257), +(71264), +(71289), +(71291), +(71296), +(71297), +(71298), +(71316), +(71317), +(71318), +(71319), +(71326), +(71327), +(71328), +(71330), +(71331), +(71335), +(71339), +(71340), +(71350), +(71361), +(71362), +(71363), +(71392), +(71405), +(71410), +(71420), +(71433), +(71434), +(71443), +(71446), +(71450), +(71459), +(71462), +(71466), +(71473), +(71475), +(71476), +(71477), +(71478), +(71479), +(71480), +(71488), +(71489), +(71490), +(71500), +(71501), +(71504), +(71510), +(71512), +(71522), +(71532), +(71533), +(71539), +(71544), +(71546), +(71547), +(71548), +(71549), +(71551), +(71552), +(71553), +(71554), +(71590), +(71591), +(71594), +(71595), +(71607), +(71623), +(71624), +(71625), +(71626), +(71646), +(71647), +(71686), +(71687), +(71688), +(71713), +(71715), +(71726), +(71727), +(71728), +(71729), +(71738), +(71745), +(71748), +(71750), +(71752), +(71757), +(71758), +(71759), +(71760), +(71778), +(71779), +(71780), +(71781), +(71782), +(71783), +(71784), +(71785), +(71786), +(71788), +(71789), +(71801), +(71806), +(71807), +(71815), +(71818), +(71819), +(71820), +(71821), +(71822), +(71823), +(71824), +(71825), +(71834), +(71838), +(71839), +(71841), +(71842), +(71847), +(71864), +(71866), +(71874), +(71879), +(71909), +(71923), +(71924), +(71925), +(71926), +(71927), +(71928), +(71930), +(71931), +(71932), +(71933), +(71934), +(71936), +(71937), +(71938), +(71951), +(71954), +(71955), +(71972), +(71988), +(72004), +(72005), +(72007), +(72008), +(72010), +(72021), +(72022), +(72023), +(72024), +(72057), +(72065), +(72066), +(72098), +(72106), +(72120), +(72121), +(72123), +(72124), +(72133), +(72163), +(72164), +(72166), +(72167), +(72171), +(72194), +(72196), +(72198), +(72208), +(72211), +(72218), +(72219), +(72222), +(72231), +(72258), +(72264), +(72265), +(72266), +(72267), +(72268), +(72269), +(72293), +(72301), +(72302), +(72303), +(72304), +(72313), +(72318), +(72319), +(72321), +(72322), +(72324), +(72326), +(72327), +(72329), +(72330), +(72333), +(72334), +(72335), +(72336), +(72360), +(72366), +(72367), +(72368), +(72369), +(72373), +(72400), +(72409), +(72410), +(72421), +(72422), +(72423), +(72424), +(72426), +(72427), +(72434), +(72437), +(72447), +(72448), +(72449), +(72451), +(72453), +(72457), +(72463), +(72465), +(72484), +(72485), +(72486), +(72487), +(72488), +(72489), +(72490), +(72491), +(72492), +(72501), +(72502), +(72503), +(72504), +(72531), +(72539), +(72540), +(72541), +(72551), +(72552), +(72553), +(72556), +(72558), +(72566), +(72567), +(72568), +(72569), +(72570), +(72571), +(72586), +(72588), +(72590), +(72597), +(72613), +(72617), +(72645), +(72671), +(72672), +(72688), +(72728), +(72756), +(72796), +(72797), +(72798), +(72804), +(72805), +(72806), +(72809), +(72810), +(72811), +(72847), +(72848), +(72865), +(72875), +(72876), +(72879), +(72883), +(72898), +(72901), +(72930), +(72960), +(72961), +(72963), +(72964), +(72965), +(72966), +(72967), +(72985), +(72995), +(73003), +(73040), +(73075), +(73076), +(73079), +(73395), +(73412), +(73488), +(73489), +(73491), +(73492), +(73499), +(73536), +(73574), +(73712), +(73771), +(73772), +(73782), +(73783), +(73784), +(73788), +(73789), +(73790), +(73797), +(73798), +(73799), +(73830), +(73832), +(73833), +(73879), +(73896), +(73906), +(73912), +(73913), +(73914), +(73943), +(73952), +(73985), +(74035), +(74046), +(74062), +(74080), +(74111), +(74162), +(74163), +(74164), +(74166), +(74184), +(74185), +(74222), +(74307), +(74325), +(74326), +(74327), +(74347), +(74367), +(74394), +(74395), +(74403), +(74404), +(74413), +(74414), +(74417), +(74421), +(74422), +(74424), +(74438), +(74445), +(74451), +(74453), +(74454), +(74470), +(74485), +(74502), +(74506), +(74507), +(74524), +(74562), +(74710), +(74749), +(74762), +(74768), +(74772), +(74774), +(74792), +(74797), +(74807), +(74812), +(74904), +(74905), +(74913), +(74978), +(74982), +(75055), +(75058), +(75082), +(75086), +(75088), +(75102), +(75159), +(75160), +(75161), +(75163), +(75168), +(75182), +(75185), +(75186), +(75188), +(75209), +(75213), +(75234), +(75314), +(75327), +(75329), +(75330), +(75331), +(75332), +(75362), +(75366), +(75367), +(75382), +(75383), +(75384), +(75412), +(75419), +(75421), +(75422), +(75423), +(75434), +(75459), +(75493), +(75494), +(75648), +(75731), +(75760), +(75780), +(75888), +(75889), +(75953), +(76096), +(76221), +(79187), +(79397); +CREATE TABLE `temp_cond_vals` +( + `spellId` INT(11), + `elseGroup` INT(11) AUTO_INCREMENT, + `entry` INT(11), + `dead` INT(11), + `errorTextId` INT(11), + `comment` VARCHAR(255), + PRIMARY KEY (`spellId`, `elseGroup`) +) ENGINE=MYISAM; + +CREATE TABLE `temp_item_spell` +( + `itemId` INT(11), + `spellId` INT(11), + PRIMARY KEY (`itemId`, `spellId`) +); + +CREATE TABLE `temp_item` +( + `itemId` INT(11), + PRIMARY KEY (`itemId`) +); + +INSERT INTO `temp_item` SELECT DISTINCT `SourceEntry` FROM `conditions` WHERE `SourceTypeOrReferenceId` = 18; +INSERT IGNORE INTO `temp_item_spell` SELECT `entry`, `spellid_1` FROM `item_template` WHERE `entry` IN (SELECT * FROM `temp_item`) AND `spellid_1` IN (SELECT * FROM `temp_convert_spells`); +INSERT IGNORE INTO `temp_item_spell` SELECT `entry`, `spellid_2` FROM `item_template` WHERE `entry` IN (SELECT * FROM `temp_item`) AND `spellid_2` IN (SELECT * FROM `temp_convert_spells`); +INSERT IGNORE INTO `temp_item_spell` SELECT `entry`, `spellid_3` FROM `item_template` WHERE `entry` IN (SELECT * FROM `temp_item`) AND `spellid_3` IN (SELECT * FROM `temp_convert_spells`); +INSERT IGNORE INTO `temp_item_spell` SELECT `entry`, `spellid_4` FROM `item_template` WHERE `entry` IN (SELECT * FROM `temp_item`) AND `spellid_4` IN (SELECT * FROM `temp_convert_spells`); +INSERT IGNORE INTO `temp_item_spell` SELECT `entry`, `spellid_5` FROM `item_template` WHERE `entry` IN (SELECT * FROM `temp_item`) AND `spellid_5` IN (SELECT * FROM `temp_convert_spells`); + +INSERT INTO `temp_cond_vals` (`spellId`, `entry`, `dead`, `errorTextId`, `comment`) SELECT DISTINCT (SELECT `spellId` FROM `temp_item_spell` WHERE `itemId` = `SourceEntry`), `ConditionValue2`, (`ConditionValue1` - 1), `ErrorTextId`, `Comment` FROM `conditions` +WHERE `SourceTypeOrReferenceId` = 18; + +#use CONDITION_OBJECT_ENTRY instead of CONDITION_ITEM_TARGET +INSERT INTO `conditions` (`SourceTypeOrReferenceId`, `SourceGroup`, `SourceEntry`, `SourceId`, `ElseGroup`, `ConditionTypeOrReference`, `ConditionTarget`, `ConditionValue1`, `ConditionValue2`, `ConditionValue3`, `NegativeCondition`, `ErrorTextId`, `Comment`) +SELECT DISTINCT 17, 0, `spellId`, 0, `elseGroup` - 1, 31, 1, 3, `entry`, 0, 0, `errorTextId`, `comment` FROM `temp_cond_vals`; +#for CONDITION_ITEM_TARGET with ConditionValue1 = DEAD we're adding !CONDITION_ALIVE as a second requirement +INSERT INTO `conditions` (`SourceTypeOrReferenceId`, `SourceGroup`, `SourceEntry`, `SourceId`, `ElseGroup`, `ConditionTypeOrReference`, `ConditionTarget`, `ConditionValue1`, `ConditionValue2`, `ConditionValue3`, `NegativeCondition`, `ErrorTextId`, `Comment`) +SELECT DISTINCT 17, 0, `spellId`, 0, `elseGroup` - 1, 36, 1, 0, 0, 0, 1, `errorTextId`, `comment` FROM `temp_cond_vals` WHERE `dead`; +#remove entries which could be converted by this sql +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` = 18 AND `SourceEntry` IN (SELECT `itemId` FROM `temp_item_spell`); +DROP TABLE `temp_convert_spells`; +DROP TABLE `temp_cond_vals`; +DROP TABLE `temp_item_spell`; +DROP TABLE `temp_item`; + +ALTER TABLE conditions DROP PRIMARY KEY; +ALTER TABLE conditions ADD PRIMARY KEY (`SourceTypeOrReferenceId`, `SourceGroup`, `SourceEntry`, `SourceId`, `ElseGroup`, `ConditionTypeOrReference`, `ConditionTarget`, `ConditionValue1`, `ConditionValue2`, `ConditionValue3`); diff --git a/sql/updates/world/2012_02_16_01_world_conditions.sql b/sql/updates/world/2012_02_16_01_world_conditions.sql new file mode 100644 index 000000000..4bcf997b8 --- /dev/null +++ b/sql/updates/world/2012_02_16_01_world_conditions.sql @@ -0,0 +1,3 @@ +UPDATE `conditions` SET ConditionValue3 = 0, ConditionTarget = 1 WHERE ConditionTypeOrReference = 1 AND ConditionValue3 = 1; +UPDATE `conditions` SET ConditionTypeOrReference = 31, ConditionValue2 = ConditionValue1, ConditionValue1 = 3, ConditionTarget = 1 WHERE ConditionTypeOrReference = 19; +UPDATE `conditions` SET ConditionTypeOrReference = 38, ConditionValue2 = 4, ConditionTarget = 1 WHERE ConditionTypeOrReference = 20; diff --git a/sql/updates/world/2012_02_17_00_world_waypoints.sql b/sql/updates/world/2012_02_17_00_world_waypoints.sql new file mode 100644 index 000000000..1cff86f5d --- /dev/null +++ b/sql/updates/world/2012_02_17_00_world_waypoints.sql @@ -0,0 +1,77 @@ +-- Pathing for Eye of Thrallmar +SET @NPC :=57585; +SET @PATH :=@NPC*10; +UPDATE `creature` SET `position_x`=203.191,`position_y`=2850.286,`position_z`=160.4257,`spawndist`=0,`MovementType`=2 WHERE `guid`=@NPC; +DELETE FROM `creature_addon` WHERE `guid`=@NPC; +INSERT INTO `creature_addon` (`guid`,`path_id`,`bytes2`) VALUES (@NPC,@PATH,1); +DELETE FROM `waypoint_data` WHERE `id`=@PATH; +INSERT INTO `waypoint_data` (`id`,`point`,`position_x`,`position_y`,`position_z`,`delay`,`move_flag`,`action`,`action_chance`,`wpguid`) VALUES +(@PATH,1,197.9876,2842.495,160.4257,0,0,0,100,0), +(@PATH,2,212.5493,2807.971,174.2035,0,0,0,100,0), +(@PATH,3,244.0748,2812.302,156.8424,0,0,0,100,0), +(@PATH,4,262.963,2839.935,173.5923,0,0,0,100,0), +(@PATH,5,249.0294,2865.575,155.9257,0,0,0,100,0), +(@PATH,6,223.3671,2870.441,169.5924,0,0,0,100,0), +(@PATH,7,203.191,2850.286,160.4257,0,0,0,100,0); + +-- Pathing for Eye of Thrallmar +SET @NPC :=57586; +SET @PATH :=@NPC*10; +UPDATE `creature` SET `position_x`=210.6249,`position_y`=2809.285,`position_z`=208.7277,`spawndist`=0,`MovementType`=2 WHERE `guid`=@NPC; +DELETE FROM `creature_addon` WHERE `guid`=@NPC; +INSERT INTO `creature_addon` (`guid`,`path_id`,`bytes2`) VALUES (@NPC,@PATH,1); +DELETE FROM `waypoint_data` WHERE `id`=@PATH; +INSERT INTO `waypoint_data` (`id`,`point`,`position_x`,`position_y`,`position_z`,`delay`,`move_flag`,`action`,`action_chance`,`wpguid`) VALUES +(@PATH,1,213.0469,2809.036,207.1722,0,0,0,100,0), +(@PATH,2,223.5349,2797.282,213.4777,0,0,0,100,0), +(@PATH,3,238.895,2805.732,213.4777,0,0,0,100,0), +(@PATH,4,252.788,2818.183,213.4777,0,0,0,100,0), +(@PATH,5,255.2734,2839.056,213.4777,0,0,0,100,0), +(@PATH,6,245.0219,2851.84,213.4777,0,0,0,100,0), +(@PATH,7,229.2117,2860.19,213.4777,0,0,0,100,0), +(@PATH,8,213.6996,2851.376,206.5887,0,0,0,100,0), +(@PATH,9,204.457,2828.248,199.6443,0,0,0,100,0), +(@PATH,10,212.4397,2807.455,199.6443,0,0,0,100,0), +(@PATH,11,241.3802,2813.464,199.6443,0,0,0,100,0), +(@PATH,12,249.7797,2829.964,199.6443,0,0,0,100,0), +(@PATH,13,244.951,2854.129,199.6443,0,0,0,100,0), +(@PATH,14,221.8344,2856.781,199.6443,0,0,0,100,0), +(@PATH,15,210.7503,2837.578,199.6443,0,0,0,100,0), +(@PATH,16,210.6249,2809.285,208.7277,0,0,0,100,0); + +-- Pathing for Eye of Thrallmar +SET @NPC :=57587; +SET @PATH :=@NPC*10; +UPDATE `creature` SET `position_x`=236.1859,`position_y`=2813.747,`position_z`=200.9708,`spawndist`=0,`MovementType`=2 WHERE `guid`=@NPC; +DELETE FROM `creature_addon` WHERE `guid`=@NPC; +INSERT INTO `creature_addon` (`guid`,`path_id`,`bytes2`) VALUES (@NPC,@PATH,1); +DELETE FROM `waypoint_data` WHERE `id`=@PATH; +INSERT INTO `waypoint_data` (`id`,`point`,`position_x`,`position_y`,`position_z`,`delay`,`move_flag`,`action`,`action_chance`,`wpguid`) VALUES +(@PATH,1,241.7692,2815.284,200.8042,0,0,0,100,0), +(@PATH,2,255.8273,2833.317,201.443,0,0,0,100,0), +(@PATH,3,247.4309,2853.592,205.1653,0,0,0,100,0), +(@PATH,4,223.9901,2858.107,208.5819,0,0,0,100,0), +(@PATH,5,208.0596,2843.793,192.3596,0,0,0,100,0), +(@PATH,6,213.9734,2816.793,188.4153,0,0,0,100,0), +(@PATH,7,236.1859,2813.747,200.9708,0,0,0,100,0); + +-- Pathing for Eye of Thrallmar +SET @NPC :=57588; +SET @PATH :=@NPC*10; +UPDATE `creature` SET `position_x`=245.9259,`position_y`=2829.09,`position_z`=177.804,`spawndist`=0,`MovementType`=2 WHERE `guid`=@NPC; +DELETE FROM `creature_addon` WHERE `guid`=@NPC; +INSERT INTO `creature_addon` (`guid`,`path_id`,`bytes2`) VALUES (@NPC,@PATH,1); +DELETE FROM `waypoint_data` WHERE `id`=@PATH; +INSERT INTO `waypoint_data` (`id`,`point`,`position_x`,`position_y`,`position_z`,`delay`,`move_flag`,`action`,`action_chance`,`wpguid`) VALUES +(@PATH,1,251.6207,2841.322,177.804,0,0,0,100,0), +(@PATH,2,241.4914,2859.113,169.6652,0,0,0,100,0), +(@PATH,3,214.9913,2858.249,176.3595,0,0,0,100,0), +(@PATH,4,210.2245,2836.028,169.7762,0,0,0,100,0), +(@PATH,5,225.7556,2822.145,169.9707,0,0,0,100,0), +(@PATH,6,237.9712,2823.874,170.1096,0,0,0,100,0), +(@PATH,7,245.9259,2829.09,177.804,0,0,0,100,0); + +DELETE FROM `creature` WHERE `guid`=57589; +UPDATE `creature_template` SET `InhabitType`=4 WHERE `entry`=16598; + + diff --git a/sql/updates/world/2012_02_18_00_world_spell_script_names.sql b/sql/updates/world/2012_02_18_00_world_spell_script_names.sql new file mode 100644 index 000000000..993fe3a2f --- /dev/null +++ b/sql/updates/world/2012_02_18_00_world_spell_script_names.sql @@ -0,0 +1,69 @@ +DELETE FROM `spell_script_names` WHERE `spell_id` in (-100,-12162,13567,17251,23019,23448,23453,25860,28089,29200,29858,30458,30507,31225,35745,37674,39090,39093,39096,42784,43723,44875,47170,49357,50243,51582,51961,52759,52845,53808,54171,54577,55004,64385,-1464,-5308,12809,23881,-1454,-50286,8171,52041,52046,52047,52048,52049,52050,52059,52060,52061,52031,52033,52034,52035,52036,58778,58779,58780,60103,-49998,-66188,-47541,52375,59134,-62900,49560,62324,31890); +INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES +(-100,'spell_warr_charge'), +(-12162,'spell_warr_deep_wounds'), +(13567,'spell_gen_dummy_trigger'), +(17251,'spell_gen_spirit_healer_res'), +(23019,'spell_item_crystal_prison_dummy_dnd'), +(23448,'spell_gen_gadgetzan_transporter_backfire'), +(23453,'spell_gen_gnomish_transporter'), +(25860,'spell_item_reindeer_transformation'), +(28089,'spell_thaddius_polarity_shift'), +(29200,'spell_item_purify_helboar_meat'), +(29858,'spell_warl_soulshatter'), +(30458,'spell_item_nigh_invulnerability'), +(30507,'spell_item_poultryizer'), +(31225,'spell_item_shimmering_vessel'), +(35745,'spell_item_socrethars_stone'), +(37674,'spell_gen_chaos_blast'), +(39090,'spell_capacitus_polarity_charge'), +(39093,'spell_capacitus_polarity_charge'), +(39096,'spell_capacitus_polarity_shift'), +(42784,'spell_astromancer_wrath_of_the_astromancer'), +(43723,'spell_item_demon_broiled_surprise'), +(44875,'spell_item_complete_raptor_capture'), +(47170,'spell_item_impale_leviroth'), +(49357,'spell_item_brewfest_mount_transformation'), +(50243,'spell_item_teach_language'), +(51582,'spell_item_rocket_boots'), +(51961,'spell_item_chicken_cover'), +(52759,'spell_sha_ancestral_awakening_proc'), +(52845,'spell_item_brewfest_mount_transformation'), +(53808,'spell_item_pygmy_oil'), +(54577,'spell_item_uded'), +(54171,'spell_pal_divine_storm_dummy'), +(55004,'spell_item_nitro_boots'), +(64385,'spell_item_unusual_compass'), +(-1464,'spell_warr_slam'), +(-5308,'spell_warr_execute'), +(12809,'spell_warr_concussion_blow'), +(23881,'spell_warr_bloodthirst'), +(-1454,'spell_warl_life_tap'), +(-50286,'spell_dru_starfall_dummy'), +(8171,'spell_sha_cleansing_totem_pulse'), +(52041,'spell_sha_healing_stream_totem'), +(52046,'spell_sha_healing_stream_totem'), +(52047,'spell_sha_healing_stream_totem'), +(52048,'spell_sha_healing_stream_totem'), +(52049,'spell_sha_healing_stream_totem'), +(52050,'spell_sha_healing_stream_totem'), +(52059,'spell_sha_healing_stream_totem'), +(52060,'spell_sha_healing_stream_totem'), +(52061,'spell_sha_healing_stream_totem'), +(52031,'spell_sha_mana_spring_totem'), +(52033,'spell_sha_mana_spring_totem'), +(52034,'spell_sha_mana_spring_totem'), +(52035,'spell_sha_mana_spring_totem'), +(52036,'spell_sha_mana_spring_totem'), +(58778,'spell_sha_mana_spring_totem'), +(58779,'spell_sha_mana_spring_totem'), +(58780,'spell_sha_mana_spring_totem'), +(60103,'spell_sha_lava_lash'), +(-49998,'spell_dk_death_strike'), +(-66188,'spell_dk_death_strike'), +(-47541,'spell_dk_death_coil'), +(52375,'spell_dk_death_coil'), +(59134,'spell_dk_death_coil'), +(-62900,'spell_dk_death_coil'), +(49560,'spell_dk_death_grip'), +(62324,'spell_vehicle_throw_passenger'); diff --git a/sql/updates/world/2012_02_18_01_world_spell_dbc.sql b/sql/updates/world/2012_02_18_01_world_spell_dbc.sql new file mode 100644 index 000000000..b343399d7 --- /dev/null +++ b/sql/updates/world/2012_02_18_01_world_spell_dbc.sql @@ -0,0 +1,3 @@ +DELETE FROM `spell_dbc` WHERE `id`=31980; +INSERT INTO `spell_dbc` (`Id`,`Dispel`,`Mechanic`,`Attributes`,`AttributesEx`,`AttributesEx2`,`AttributesEx3`,`AttributesEx4`,`AttributesEx5`,`AttributesEx6`,`AttributesEx7`,`Stances`,`StancesNot`,`Targets`,`CastingTimeIndex`,`AuraInterruptFlags`,`ProcFlags`,`ProcChance`,`ProcCharges`,`MaxLevel`,`BaseLevel`,`SpellLevel`,`DurationIndex`,`RangeIndex`,`StackAmount`,`EquippedItemClass`,`EquippedItemSubClassMask`,`EquippedItemInventoryTypeMask`,`Effect1`,`Effect2`,`Effect3`,`EffectDieSides1`,`EffectDieSides2`,`EffectDieSides3`,`EffectRealPointsPerLevel1`,`EffectRealPointsPerLevel2`,`EffectRealPointsPerLevel3`,`EffectBasePoints1`,`EffectBasePoints2`,`EffectBasePoints3`,`EffectMechanic1`,`EffectMechanic2`,`EffectMechanic3`,`EffectImplicitTargetA1`,`EffectImplicitTargetA2`,`EffectImplicitTargetA3`,`EffectImplicitTargetB1`,`EffectImplicitTargetB2`,`EffectImplicitTargetB3`,`EffectRadiusIndex1`,`EffectRadiusIndex2`,`EffectRadiusIndex3`,`EffectApplyAuraName1`,`EffectApplyAuraName2`,`EffectApplyAuraName3`,`EffectAmplitude1`,`EffectAmplitude2`,`EffectAmplitude3`,`EffectMultipleValue1`,`EffectMultipleValue2`,`EffectMultipleValue3`,`EffectMiscValue1`,`EffectMiscValue2`,`EffectMiscValue3`,`EffectMiscValueB1`,`EffectMiscValueB2`,`EffectMiscValueB3`,`EffectTriggerSpell1`,`EffectTriggerSpell2`,`EffectTriggerSpell3`,`EffectSpellClassMaskA1`,`EffectSpellClassMaskA2`,`EffectSpellClassMaskA3`,`EffectSpellClassMaskB1`,`EffectSpellClassMaskB2`,`EffectSpellClassMaskB3`,`EffectSpellClassMaskC1`,`EffectSpellClassMaskC2`,`EffectSpellClassMaskC3`,`MaxTargetLevel`,`SpellFamilyName`,`SpellFamilyFlags1`,`SpellFamilyFlags2`,`SpellFamilyFlags3`,`MaxAffectedTargets`,`DmgClass`,`PreventionType`,`DmgMultiplier1`,`DmgMultiplier2`,`DmgMultiplier3`,`AreaGroupId`,`SchoolMask`,`Comment`) VALUES +(31980,0,0,328064,1024,4,268894208,0,0,0,0,0,0,0,1,0,0,101,0,0,14,14,0,13,0,-1,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,15,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,4,0,0,0,0,1,0,0,0,1,"Righteous Defense Trigger Spell"); diff --git a/sql/updates/world/2012_02_18_02_world_gossip.sql b/sql/updates/world/2012_02_18_02_world_gossip.sql new file mode 100644 index 000000000..c72532e3f --- /dev/null +++ b/sql/updates/world/2012_02_18_02_world_gossip.sql @@ -0,0 +1,52 @@ +-- Gossip for Lore Keeper of Norgannon "Uldaman" for quest 2278 "The Platinum Discs" +UPDATE `creature_template` SET `gossip_menu_id`=562 WHERE `entry`=7172; + +-- SAI for Lore Keeper of Norgannon +SET @ENTRY := 7172; +UPDATE `creature_template` SET `AIName`='SmartAI',`ScriptName`='' WHERE `entry`=@ENTRY; +DELETE FROM `smart_scripts` WHERE `source_type`=0 AND `entryorguid`=@ENTRY; +INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES +(@ENTRY,0,0,1,62,0,100,0,576,0,0,0,72,0,0,0,0,0,0,7,0,0,0,0,0,0,0, 'Lore Keeper of Norgannon - On gossip option select - close gossip'), +(@ENTRY,0,1,0,61,0,100,0,0,0,0,0,26,2278,0,0,0,0,0,7,0,0,0,0,0,0,0, 'Lore Keeper of Norgannon - On gossip option select - give quest credit'); + +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=562 AND `SourceEntry`=0; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(15,562,0,0,9,2278,0,0,0,'','Show gossip option if player has quest 2278 but not complete'); + +DELETE FROM `gossip_menu` WHERE `entry` BETWEEN 561 AND 576; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES +(561,1080), +(562,1079), +(563,1081), +(564,1082), +(565,1083), +(566,1084), +(567,1085), +(568,1086), +(569,1087), +(570,1088), +(571,1089), +(572,1090), +(573,1091), +(574,1092), +(575,1093), +(576,1094); + +DELETE FROM `gossip_menu_option` WHERE `menu_id` BETWEEN 561 AND 576; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(561,0,0,'What is a "subterranean being matrix"?',1,1,563,0,0,0,''), +(562,0,0,'Who are the Earthen?',1,1,561,0,0,0,''), +(563,0,0,'What are the anomalies you speak of?',1,1,564,0,0,0,''), +(564,0,0,'What is a "resilient foundation of construction"?',1,1,565,0,0,0,''), +(565,0,0,'So... the Earthen were made out of stone?',1,1,566,0,0,0,''), +(566,0,0,'Anything else I should know about the Earthen?',1,1,567,0,0,0,''), +(567,0,0,'I think I understand the Creators'' design intent for the Earthen now. What are the Earthen''s anomalies that you spoke of earlier?',1,1,568,0,0,0,''), +(568,0,0,'What high-stress environments would cause the Earthen to destabilize?',1,1,569,0,0,0,''), +(569,0,0,'What happens when the Earthen destabilize?',1,1,570,0,0,0,''), +(570,0,0,'Troggs?! Are the troggs you mention the same as the ones in the world today?',1,1,571,0,0,0,''), +(571,0,0,'You mentioned two results when the Earthen destabilize. What is the second?',1,1,572,0,0,0,''), +(572,0,0,'Dwarves!!! Now you''re telling me that dwarves originally came from the Earthen?!',1,1,573,0,0,0,''), +(573,0,0,'These dwarves are the same ones today, yes? Do dwarves maintain any other links to the Earthen?',1,1,574,0,0,0,''), +(574,0,0,'Who are the Creators?',1,1,575,0,0,0,''), +(575,0,0,'This is a lot to think about.',1,1,576,0,0,0,''), +(576,0,0,'I will access the discs now.',1,1,0,0,0,0,''); \ No newline at end of file diff --git a/sql/updates/world/2012_02_18_03_world_gossip.sql b/sql/updates/world/2012_02_18_03_world_gossip.sql new file mode 100644 index 000000000..990006f50 --- /dev/null +++ b/sql/updates/world/2012_02_18_03_world_gossip.sql @@ -0,0 +1,1068 @@ +-- XXXXXXXXXXXXXXXXXXXX +-- X Rogue Trainers X +-- XXXXXXXXXXXXXXXXXXXX + +UPDATE `creature_template` SET `gossip_menu_id`=410 WHERE `entry`=1234; +UPDATE `creature_template` SET `gossip_menu_id`=85 WHERE `entry`=2122; +UPDATE `creature_template` SET `gossip_menu_id`=3984 WHERE `entry`=6707; +UPDATE `creature_template` SET `gossip_menu_id`=4512 WHERE `entry`=3328; +UPDATE `creature_template` SET `gossip_menu_id`=4575 WHERE `entry`=4215; +UPDATE `creature_template` SET `gossip_menu_id`=4577 WHERE `entry`=4214; +UPDATE `creature_template` SET `gossip_menu_id`=4658 WHERE `entry`=1411; + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 85; +SET @TEXTYES := 581; +SET @TEXTNO := 4796; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 141; +SET @TEXTYES := 638; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 381; +SET @TEXTYES := 878; +SET @TEXTNO := 4799; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am in need of training, Keryn.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 410; +SET @TEXTYES := 4795; +SET @TEXTNO := 4797; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 411; +SET @TEXTYES := 908; +SET @TEXTNO := 4798; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Good day, Hulfdan, I am looking for training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 436; +SET @TEXTYES := 934; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Hello! I am a Rogue in need of training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 3984; +SET @TEXTYES := 4838; +SET @TEXTNO := 4839; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Yes, I have. Teach me.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4502; +SET @TEXTYES := 4835; +SET @TEXTNO := 4837; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Can you train me how to use rogue skills?",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4512; +SET @TEXTYES := 638; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4513; +SET @TEXTYES := 638; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4540; +SET @TEXTYES := 581; +SET @TEXTNO := 4796; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4541; +SET @TEXTYES := 581; +SET @TEXTNO := 4796; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4542; +SET @TEXTYES := 581; +SET @TEXTNO := 4796; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I would like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4561; +SET @TEXTYES := 5695; +SET @TEXTNO := 4833; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I'm lookin' for rogue trainin'.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4562; +SET @TEXTYES := 4834; +SET @TEXTNO := 4833; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I'm lookin' for rogue trainin'.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4575; +SET @TEXTYES := 4795; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4576; +SET @TEXTYES := 4795; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4577; +SET @TEXTYES := 4795; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4658; +SET @TEXTYES := 6165; +SET @TEXTNO := 6164; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Can you train me how to use rogue skills?",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4659; +SET @TEXTYES := 4835; +SET @TEXTNO := 4837; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Can you train me how to use rogue skills?",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4676; +SET @TEXTYES := 4835; +SET @TEXTNO := 4833; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Can you train me how to use rogue skills?",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 4690; +SET @TEXTYES := 4795; +SET @TEXTNO := 4793; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 5061; +SET @TEXTYES := 4835; +SET @TEXTNO := 4837; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Can you train me how to use rogue skills?",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- Gossip Condition for Rogue Trainers +SET @GOSSIP := 6650; +SET @TEXTYES := 9188; +SET @TEXTNO := 9187; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,8,0,0,0,'','Show gossip text if player is a Rogue'), +(14,@GOSSIP,@TEXTNO,0,15,1527,0,0,0,'','Show gossip text if player is not a Rogue'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I require rogue training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''), +(@GOSSIP,4,0,"",1,1,0,0,0,0,''); + +-- XXXXXXXXXXXXXXXXXXXXX +-- X Hunter Trainers X +-- XXXXXXXXXXXXXXXXXXXXX + +UPDATE `creature_template` SET `gossip_menu_id`=4657 WHERE `entry`=1404; +UPDATE `creature_template` SET `gossip_menu_id`=4695 WHERE `entry`=3596; +UPDATE `creature_template` SET `gossip_menu_id`=4009 WHERE `entry`=3601; +UPDATE `creature_template` SET `gossip_menu_id`=6652 WHERE `entry`=16672; +UPDATE `creature_template` SET `gossip_menu_id`=4101 WHERE `entry`=987; + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4008; +SET @TEXTYES := 4863; +SET @TEXTNO := 4993; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I'd like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4009; +SET @TEXTYES := 4316; +SET @TEXTNO := 4993; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am in need of training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4010; +SET @TEXTYES := 4866; +SET @TEXTNO := 5003; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I have come for training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4011; +SET @TEXTYES := 4867; +SET @TEXTNO := 4998; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am in need of training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4012; +SET @TEXTYES := 4868; +SET @TEXTNO := 4998; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am a hunter and wish to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4017; +SET @TEXTYES := 4888; +SET @TEXTNO := 4888; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"Please train me.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4023; +SET @TEXTYES := 4889; +SET @TEXTNO := 4996; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I wish to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4101; +SET @TEXTYES := 5001; +SET @TEXTNO := 5002; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4472; +SET @TEXTYES := 4893; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4473; +SET @TEXTYES := 4893; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4474; +SET @TEXTYES := 4893; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4506; +SET @TEXTYES := 4987; +SET @TEXTNO := 5004; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I wish to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4524; +SET @TEXTYES := 4997; +SET @TEXTNO := 4998; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4549; +SET @TEXTYES := 4999; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4550; +SET @TEXTYES := 4890; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am here for training.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4551; +SET @TEXTYES := 4999; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4647; +SET @TEXTYES := 4997; +SET @TEXTNO := 4998; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4648; +SET @TEXTYES := 4987; +SET @TEXTNO := 5004; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I wish to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4657; +SET @TEXTYES := 5001; +SET @TEXTNO := 5002; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4675; +SET @TEXTYES := 4999; +SET @TEXTNO := 5000; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4693; +SET @TEXTYES := 6160; +SET @TEXTNO := 4993; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I'd like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 4695; +SET @TEXTYES := 4863; +SET @TEXTNO := 4993; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I'd like to train.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 6652; +SET @TEXTYES := 9190; +SET @TEXTNO := 9189; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 7262; +SET @TEXTYES := 8585; +SET @TEXTNO := 8586; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I seek training in the ways of the Hunter.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Gossip Condition for Hunter Trainers +SET @GOSSIP := 7368; +SET @TEXTYES := 8804; +SET @TEXTNO := 8823; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId` IN (14,15) AND `SourceGroup`=@GOSSIP; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,@GOSSIP,@TEXTYES,0,15,4,0,0,0,'','Show gossip text if player is a Hunter'), +(14,@GOSSIP,@TEXTNO,0,15,1531,0,0,0,'','Show gossip text if player is not a Hunter'); +-- Add Any Missing Gossip Menu item +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTYES; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTYES); +DELETE FROM `gossip_menu` WHERE `entry`=@GOSSIP AND `text_id`=@TEXTNO; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (@GOSSIP,@TEXTNO); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE menu_id=@GOSSIP; +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(@GOSSIP,0,3,"I am a hunter in need of training, Acteon.",5,16,0,0,0,0,''), +(@GOSSIP,1,0,"I wish to unlearn my talents.",16,16,4461,0,0,0,''), +(@GOSSIP,2,0,"I wish to know about Dual Talent Specialization.",1,1,10371,0,0,0,''); + +-- Add some missing gossip from sniff for Zabra'jin in Zangermarsh +UPDATE `creature_template` SET `gossip_menu_id`=7601 WHERE `entry`=18013; +UPDATE `creature_template` SET `gossip_menu_id`=7602 WHERE `entry`=18014; +UPDATE `creature_template` SET `gossip_menu_id`=7608 WHERE `entry`=18015; +UPDATE `creature_template` SET `gossip_menu_id`=7603 WHERE `entry`=18017; +UPDATE `creature_template` SET `gossip_menu_id`=7609 WHERE `entry`=18018; +UPDATE `creature_template` SET `gossip_menu_id`=9821 WHERE `entry`=18244; +UPDATE `creature_template` SET `gossip_menu_id`=7722 WHERE `entry`=18564; + +DELETE FROM `gossip_menu` WHERE `entry` IN (7601,7602,7603,7608,7609,7722,7946,9821); +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES +(7601,9248),(7602,9249),(7603,9250),(7608,9259), +(7609,9260),(7722,9431),(7946,9752),(9821,13584); + +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (7603,7608,7609) AND `id` IN (0); +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (7609,7722,9821) AND `id` IN (1); +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(7603,0,1,'I would like to buy from you.',3,128,0,0,0,0,''), +(7608,0,1,'I wish to purchase tradeskill supplies.',3,128,0,0,0,0,''), +(7609,0,1,'I wish to purchase fishing supplies.',3,128,0,0,0,0,''), +(7609,1,3,'Give me some pointers on my fishing technique.',5,16,0,0,0,0,''), +(7722,1,1,'I have marks to redeem!',3,128,0,0,0,0,''), +(9821,1,1,'I''m looking for a lost companion.',14,4194304,0,0,0,0,''); + +-- Add some missing gossip from sniff for Thunderlord Stronghold in Blade's Edge Mountains +UPDATE `creature_template` SET `gossip_menu_id`=9856 WHERE `entry`=19471; +UPDATE `creature_template` SET `gossip_menu_id`=9821 WHERE `entry`=19476; +UPDATE `creature_template` SET `gossip_menu_id`=5856 WHERE `entry`=19478; +UPDATE `creature_template` SET `gossip_menu_id`=8283 WHERE `entry`=21311; +UPDATE `creature_template` SET `gossip_menu_id`=8406 WHERE `entry`=21950; +UPDATE `creature_template` SET `gossip_menu_id`=8244 WHERE `entry`=21147; +UPDATE `creature_template` SET `gossip_menu_id`=8525 WHERE `entry`=21984; +UPDATE `creature_template` SET `gossip_menu_id`=8239 WHERE `entry`=21117; + +DELETE FROM `gossip_menu` WHERE `entry` IN (8283,8406,8244,8525,8239); +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES +(8283,10322),(8406,10508),(8244,10259),(8525,10661),(8239,10251); + +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (9856) AND `id` IN (0); +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(9856,0,1,'Show me what you have for sale.',3,128,0,0,0,0,''); + diff --git a/sql/updates/world/2012_02_18_04_world_spell_script_names.sql b/sql/updates/world/2012_02_18_04_world_spell_script_names.sql new file mode 100644 index 000000000..8fa5bc551 --- /dev/null +++ b/sql/updates/world/2012_02_18_04_world_spell_script_names.sql @@ -0,0 +1,6 @@ +DELETE FROM `spell_script_names` WHERE `spell_id` IN (52059,52060,52061); +DELETE FROM `spell_script_names` WHERE `spell_id` IN (58759,58760,58761); +INSERT INTO `spell_script_names` (`spell_id`,`ScriptName`) VALUES +(58759,'spell_sha_healing_stream_totem'), +(58760,'spell_sha_healing_stream_totem'), +(58761,'spell_sha_healing_stream_totem'); diff --git a/sql/updates/world/2012_02_18_05_world_creatures.sql b/sql/updates/world/2012_02_18_05_world_creatures.sql new file mode 100644 index 000000000..3fdac99c8 --- /dev/null +++ b/sql/updates/world/2012_02_18_05_world_creatures.sql @@ -0,0 +1,3 @@ +UPDATE `creature` SET `MovementType`=1 WHERE `spawndist`!=0 AND `MovementType`=2 AND `guid` IN (49123,49124,49125,49127,49128,49129,49143,49144,49145,49146,49150,49151,49154,49156,49157,49158,49167,49186,49187,49188,49318,49319,49664,49665,49751,49762,51398,51402,51422,51423,123148,127753,137490,137491,202314); +UPDATE `creature` SET `MovementType`=0 WHERE `spawndist`=0 AND `MovementType`=2 AND `guid` IN (49123,49124,49125,49127,49128,49129,49143,49144,49145,49146,49150,49151,49154,49156,49157,49158,49167,49186,49187,49188,49318,49319,49664,49665,49751,49762,51398,51402,51422,51423,123148,127753,137490,137491,202314); +UPDATE `creature_template` SET `MovementType`=0 WHERE `MovementType`=2 AND `entry` NOT IN (21657,30007); diff --git a/sql/updates/world/2012_02_18_06_world_gossip.sql b/sql/updates/world/2012_02_18_06_world_gossip.sql new file mode 100644 index 000000000..e3385ceb5 --- /dev/null +++ b/sql/updates/world/2012_02_18_06_world_gossip.sql @@ -0,0 +1,166 @@ +-- Add some missing gossip to Nagrand From UDB +UPDATE `creature_template` SET `gossip_menu_id`=7675 WHERE `entry`=18261; +UPDATE `creature_template` SET `gossip_menu_id`=7723 WHERE `entry`=18333; +UPDATE `creature_template` SET `gossip_menu_id`=7719 WHERE `entry`=18417; +UPDATE `creature_template` SET `gossip_menu_id`=7724 WHERE `entry`=18581; +UPDATE `creature_template` SET `gossip_menu_id`=7625 WHERE `entry`=18265; +UPDATE `creature_template` SET `gossip_menu_id`=7626 WHERE `entry`=18276; +UPDATE `creature_template` SET `gossip_menu_id`=7631 WHERE `entry`=18335; +UPDATE `creature_template` SET `gossip_menu_id`=7699 WHERE `entry`=18471; +UPDATE `creature_template` SET `gossip_menu_id`=7563 WHERE `entry`=18074; +UPDATE `creature_template` SET `gossip_menu_id`=7592 WHERE `entry`=18200; +UPDATE `creature_template` SET `gossip_menu_id`=7579 WHERE `entry`=18180; +UPDATE `creature_template` SET `gossip_menu_id`=7607 WHERE `entry`=18218; +UPDATE `creature_template` SET `gossip_menu_id`=7704 WHERE `entry`=18482; +UPDATE `creature_template` SET `gossip_menu_id`=8493, `npcflag`=`npcflag`|1 WHERE `entry`=22113; + +DELETE FROM `gossip_menu` WHERE `entry`=7563 AND `text_id`=9181; +DELETE FROM `gossip_menu` WHERE `entry`=7578 AND `text_id`=9220; +DELETE FROM `gossip_menu` WHERE `entry`=7579 AND `text_id` IN (9219,9221,9256,9257); +DELETE FROM `gossip_menu` WHERE `entry`=7592 AND `text_id` IN (9240,9283,9284); +DELETE FROM `gossip_menu` WHERE `entry`=7607 AND `text_id` IN (9258,9286); +DELETE FROM `gossip_menu` WHERE `entry`=7625 AND `text_id`=9287; +DELETE FROM `gossip_menu` WHERE `entry`=7626 AND `text_id`=9288; +DELETE FROM `gossip_menu` WHERE `entry`=7631 AND `text_id`=9312; +DELETE FROM `gossip_menu` WHERE `entry`=7675 AND `text_id` IN (9361,9369); +DELETE FROM `gossip_menu` WHERE `entry`=7676 AND `text_id`=9368; +DELETE FROM `gossip_menu` WHERE `entry`=7677 AND `text_id`=9367; +DELETE FROM `gossip_menu` WHERE `entry`=7678 AND `text_id`=9366; +DELETE FROM `gossip_menu` WHERE `entry`=7679 AND `text_id`=9365; +DELETE FROM `gossip_menu` WHERE `entry`=7680 AND `text_id`=9364; +DELETE FROM `gossip_menu` WHERE `entry`=7681 AND `text_id`=9363; +DELETE FROM `gossip_menu` WHERE `entry`=7682 AND `text_id`=9362; +DELETE FROM `gossip_menu` WHERE `entry`=7699 AND `text_id`=9394; +DELETE FROM `gossip_menu` WHERE `entry`=7704 AND `text_id`=9405; +DELETE FROM `gossip_menu` WHERE `entry`=7705 AND `text_id`=9406; +DELETE FROM `gossip_menu` WHERE `entry`=7714 AND `text_id`=9424; +DELETE FROM `gossip_menu` WHERE `entry`=7715 AND `text_id`=9423; +DELETE FROM `gossip_menu` WHERE `entry`=7716 AND `text_id`=9422; +DELETE FROM `gossip_menu` WHERE `entry`=7717 AND `text_id`=9421; +DELETE FROM `gossip_menu` WHERE `entry`=7718 AND `text_id`=9420; +DELETE FROM `gossip_menu` WHERE `entry`=7719 AND `text_id` IN (9419,9427); +DELETE FROM `gossip_menu` WHERE `entry`=7723 AND `text_id`=9429; +DELETE FROM `gossip_menu` WHERE `entry`=7724 AND `text_id`=9433; +DELETE FROM `gossip_menu` WHERE `entry`=8393 AND `text_id`=10493; +DELETE FROM `gossip_menu` WHERE `entry`=8394 AND `text_id`=10492; +DELETE FROM `gossip_menu` WHERE `entry`=8394 AND `text_id`=10614; -- was incorrect in the db +DELETE FROM `gossip_menu` WHERE `entry`=8395 AND `text_id`=10494; +DELETE FROM `gossip_menu` WHERE `entry`=8395 AND `text_id`=10615; -- was incorrect in the db +DELETE FROM `gossip_menu` WHERE `entry`=8396 AND `text_id`=10495; +DELETE FROM `gossip_menu` WHERE `entry`=8396 AND `text_id`=10616; -- was incorrect in the db +DELETE FROM `gossip_menu` WHERE `entry`=8398 AND `text_id`=10497; +DELETE FROM `gossip_menu` WHERE `entry`=8493 AND `text_id` IN (10606,10655,10854); +DELETE FROM `gossip_menu` WHERE `entry`=8497 AND `text_id`=10616; +DELETE FROM `gossip_menu` WHERE `entry`=8498 AND `text_id`=10615; +DELETE FROM `gossip_menu` WHERE `entry`=8499 AND `text_id`=10614; +DELETE FROM `gossip_menu` WHERE `entry` BETWEEN 21296 AND 21303; -- the old menus assigned to Lantresor which were not sniffed +DELETE FROM `gossip_menu` WHERE `entry` BETWEEN 21304 AND 21309; -- the old menus assigned to Altruis which were not sniffed +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES +(7563,9181), +(7578,9220), +(7579,9219),(7579,9221),(7579,9256),(7579,9257), +(7592,9240),(7592,9283),(7592,9284), +(7625,9287), +(7626,9288), +(7631,9312), +(7699,9394), +(7607,9258),(7607,9286), +(7675,9361),(7675,9369), +(7676,9368), +(7677,9367), +(7678,9366), +(7679,9365), +(7680,9364), +(7681,9363), +(7682,9362), +(7704,9405), +(7705,9406), +(7714,9424), +(7715,9423), +(7716,9422), +(7717,9421), +(7718,9420), +(7719,9419),(7719,9427), +(7723,9429), +(7724,9433), +(8394,10492), +(8393,10493), +(8395,10494), +(8396,10495), +(8398,10497), +(8493,10606),(8493,10655),(8493,10854), +(8497,10616), +(8498,10615), +(8499,10614); + +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (7579,7704,7715,7716,7717,7718,7719,8393,8394,8395,8396,8398,8497,8498,8499) AND `id`=0; +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (7719,7724) AND `id`=1; +DELETE FROM `gossip_menu_option` WHERE `menu_id` BETWEEN 7675 AND 7682 AND `id`=0; +UPDATE `gossip_menu_option` SET `action_menu_id`=8499 WHERE `menu_id`=8397; -- was incorrect +DELETE FROM `gossip_menu_option` WHERE `menu_id` BETWEEN 21296 AND 21303; -- the old options assigned to Lantresor which were not sniffed +DELETE FROM `gossip_menu_option` WHERE `menu_id` BETWEEN 21304 AND 21309; -- the old options assigned to Altruis which was not sniffed +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(7579,0,0,'Hemet Nesingwary, what are you doing here in the Outland?',1,1,7578,0,0,0,''), +(7704,0,0,'Empoor, you''re going to tell me what I want to know, or else!',1,1,0,0,0,0,''), +(7715,0,0,'Forge camps?',1,1,7714,0,0,0,''), +(7716,0,0,'How do you see them now?',1,1,7715,0,0,0,''), +(7717,0,0,'And now?',1,1,7716,0,0,0,''), +(7718,0,0,'Legion?',1,1,7717,0,0,0,''), +(7719,0,0,'I see twisted steel and smell sundered earth.',1,1,7718,0,0,0,''), +(7719,1,0,'Tell me about the demon hunter training grounds at the Ruins of Karabor.',1,1,8394,0,0,0,''), +(7724,1,1,'I have marks to redeem!',3,128,0,0,0,0,''), +(7675,0,0,'I have killed many of your ogres, Lantresor. I have no fear.',1,1,7682,0,0,0,''), +(7682,0,0,'Should I know? You look like an orc to me.',1,1,7681,0,0,0,''), +(7681,0,0,'And the other half?',1,1,7680,0,0,0,''), +(7680,0,0,'I have heard of your kind, but I never thought to see the day when I would meet a half-breed.',1,1,7679,0,0,0,''), +(7679,0,0,'My apologies. I did not mean to offend. I am here on behalf of my people.',1,1,7678,0,0,0,''), +(7678,0,0,'My people ask that you pull back your Boulderfist ogres and cease all attacks on our territories. In return, we will also pull back our forces.',1,1,7677,0,0,0,''), +(7677,0,0,'We will fight you until the end, then, Lantresor. We will not stand idly by as you pillage our towns and kill our people.',1,1,7676,0,0,0,''), +(7676,0,0,'What do I need to do?',1,1,0,0,0,0,''), +(8394,0,0,'I''m listening.',1,1,8393,0,0,0,''), +(8393,0,0,'Go on, please.',1,1,8395,0,0,0,''), +(8395,0,0,'Interesting.',1,1,8396,0,0,0,''), +(8396,0,0,'That''s quite a story.',1,1,8398,0,0,0,''), +(8398,0,0,'There was something else I wanted to ask you, Altruis.',1,1,7719,0,0,0,''), +(8499,0,0,'But you are dragons! How could orcs do this to you?',1,1,8498,0,0,0,''), +(8498,0,0,'Your mate?',1,1,8497,0,0,0,''), +(8497,0,0,'I have battled many beasts, dragon. I will help you.',1,1,0,0,0,0,''); + +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=7579 AND `SourceEntry` IN (9221,9256,9257); +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=7592 AND `SourceEntry` IN (9283,9284); +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=7607 AND `SourceEntry`=9286; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=7675 AND `SourceEntry`=9369; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=7719 AND `SourceEntry`=9427; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=8493 AND `SourceEntry` IN (10655,10854); +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=7675 AND `SourceEntry`=0; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup` IN (7704,7719) AND `SourceEntry`=0; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup` IN (7719) AND `SourceEntry`=1; +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=21304; -- condition for Altruis' gossip that wasn't sniffed +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=21295; -- condition for Lantresor's gossip that wasn't sniffed +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`SourceId`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,7579,9221,0,0,8,208,0,0,0,0,'','Show different gossip if player has rewarded quest 208'), +(14,7579,9256,0,0,8,9851,0,0,0,0,'','Show different gossip if player has rewarded quest 9851'), +(14,7579,9257,0,0,8,9852,0,0,0,0,'','Show different gossip if player has rewarded quest 9852'), +(14,7592,9283,0,0,8,9854,0,0,0,0,'','Show different gossip if player has rewarded quest 9854'), +(14,7592,9284,0,0,8,9856,0,0,0,0,'','Show different gossip if player has rewarded quest 9856'), +(14,7607,9286,0,0,8,9859,0,0,0,0,'','Show different gossip if player has rewarded quest 9859'), +(14,7675,9369,0,0,8,10107,0,0,0,0,'','Show different gossip if player has rewarded quest 10107'), +(14,7675,9369,0,1,8,10108,0,0,0,0,'','Show different gossip if player has rewarded quest 10108'), +(14,7719,9427,0,0,8,9991,0,0,0,0,'','Show different gossip if player has rewarded quest 9991'), +(14,8493,10655,0,0,8,10870,0,0,0,0,'','Show different gossip if player has rewarded quest 10870'), +(14,8493,10854,0,0,8,11012,0,0,0,0,'','Show different gossip if player has rewarded quest 11012'), +(15,7675,0,0,0,9,10107,0,0,0,0,'','Show gossip option if player has quest 10107 but not complete'), +(15,7675,0,0,1,9,10108,0,0,0,0,'','Show gossip option if player has quest 10108 but not complete'), +(15,7704,0,0,0,9,9978,0,0,0,0,'','Show gossip option if player has quest 9978 but not complete'), +(15,7719,0,0,0,8,9991,0,0,1,0,'','Show gossip option if player has not rewarded quest 9991'), +(15,7719,1,0,0,9,10646,0,0,0,0,'','Show gossip option if player has quest 10646 but not complete'); + +UPDATE `smart_scripts` SET `event_param1`=7715 WHERE `entryorguid`=18417 AND `id` IN (0,1); -- correct Altruis' script +UPDATE `smart_scripts` SET `event_param1`=8396 WHERE `entryorguid`=18417 AND `id`=2; + +UPDATE `smart_scripts` SET `event_param1`=8497 WHERE `entryorguid`=21657 AND `id`=0; -- correct Neltharaku's script + +UPDATE `smart_scripts` SET `link`=3, `event_param1`=7676 WHERE `entryorguid`=18261 AND `id` IN (1,2); -- correct Lantresor's script +DELETE FROM `smart_scripts` WHERE `entryorguid`=18261 AND `id`=3; +INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES +(18261,0,3,0,61,0,100,0,0,0,0,0,72,0,0,0,0,0,0,7,0,0,0,0,0,0,0,'Lantresor - On gossip select - Close gossip'); diff --git a/sql/updates/world/2012_02_18_07_world_gossip.sql b/sql/updates/world/2012_02_18_07_world_gossip.sql new file mode 100644 index 000000000..6246f12ce --- /dev/null +++ b/sql/updates/world/2012_02_18_07_world_gossip.sql @@ -0,0 +1,44 @@ +-- Fallen Hero of the Horde http://old.wowhead.com/npc=7572 +DELETE FROM `gossip_menu` WHERE `entry`=840 AND `text_id`=1451; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (840,1451); +DELETE FROM `gossip_menu` WHERE `entry`=880 AND `text_id`=1452; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (880,1452); +DELETE FROM `gossip_menu` WHERE `entry`=881 AND `text_id`=1456; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (881,1456); +DELETE FROM `gossip_menu` WHERE `entry`=882 AND `text_id`=1455; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (882,1455); +DELETE FROM `gossip_menu` WHERE `entry`=883 AND `text_id`=1454; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (883,1454); +DELETE FROM `gossip_menu` WHERE `entry`=884 AND `text_id`=1453; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (884,1453); +-- Text Conditions +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=840 AND `SourceEntry` IN (1391); +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(14,840,1391,0,8,2784,0,0,0,'','Show gossip text if player has quest 2801 or 2784 completed'), -- It's hard to imagine that so much death and despair could be confined to such a small area; yet beyond the swamp is a land plagued by chaos and destruction.$B$BWatch your step, adventurer. The Blasted Lands are the final resting place to far greater beings than you. +(14,840,1391,1,8,2801,0,0,0,'','Show gossip text if player has quest 2801 or 2784 completed'); -- It's hard to imagine that so much death and despair could be confined to such a small area; yet beyond the swamp is a land plagued by chaos and destruction.$B$BWatch your step, adventurer. The Blasted Lands are the final resting place to far greater beings than you. +-- Gossip option conditions +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=840; +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`,`ConditionTypeOrReference`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`ErrorTextId`,`ScriptName`,`Comment`) VALUES +(15,840,0,0,9,2784,0,0,0,'','Show gossip option if player has quest 2784 but not complete'), +(15,840,1,0,9,2801,0,0,0,'','Show gossip option if player has quest 2801 but not complete'), +(15,840,2,0,9,2702,0,0,0,'','Show gossip option if player has quest 2702 but not complete'); +-- Add Any Missing Gossip Option +DELETE FROM `gossip_menu_option` WHERE `menu_id`=840 AND `id` IN (0,1); +DELETE FROM `gossip_menu_option` WHERE `menu_id` IN (880,881,882,883,884) AND `id` IN (0); +INSERT INTO `gossip_menu_option` (`menu_id`, `id`, `option_icon`,`option_text`,`option_id`,`npc_option_npcflag`,`action_menu_id`,`action_poi_id`,`box_coded`,`box_money`,`box_text`)VALUES +(840,0,0,"Please continue, Hero...",1,1,880,0,0,0,''), +(840,1,0,"Please continue, Hero...",1,1,880,0,0,0,''), +(880,0,0,"What could be worse than death?",1,1,884,0,0,0,''), +(881,0,0,"I shall.",1,1,0,0,0,0,''), +(882,0,0,"You can count on me, Hero.",1,1,881,0,0,0,''), +(883,0,0,"What are the stones of binding?",1,1,882,0,0,0,''), +(884,0,0,"Subordinates?",1,1,883,0,0,0,''); +-- Fallen Hero of the Horde SAI +UPDATE `creature_template` SET `AIName`='SmartAI',`ScriptName`='' WHERE `entry`=7572; +DELETE FROM `smart_scripts` WHERE (`entryorguid`=7572 AND `source_type`=0); +INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES +(7572,0,0,1,62,0,100,0,881,0,0,0,26,2784,0,0,0,0,0,7,0,0,0,0,0,0,0,'Fallen Hero of the Horde - On Gossip option select - complete quest 2784'), +(7572,0,1,2,61,0,100,0,0,0,0,0,26,2801,0,0,0,0,0,7,0,0,0,0,0,0,0,'Fallen Hero of the Horde - On Gossip option select - complete quest 2801'), +(7572,0,2,0,61,0,100,0,0,0,0,0,72,0,0,0,0,0,0,7,0,0,0,0,0,0,0,'Fallen Hero of the Horde - On Gossip option select - Close Gossip'), +(7572,0,3,4,62,0,100,0,840,2,0,0,12,7750,1,180000,0,0,0,8,0,0,0,-10630.3,-2987.05,28.96,4.54,'Fallen Hero of the Horde - On Gossip option select - Spawn Corporal Thund Splithoof'), +(7572,0,4,0,61,0,100,0,0,0,0,0,72,0,0,0,0,0,0,7,0,0,0,0,0,0,0,'Fallen Hero of the Horde - On Gossip option select - Close Gossip'); diff --git a/sql/updates/world/2012_02_18_08_world_gossip.sql b/sql/updates/world/2012_02_18_08_world_gossip.sql new file mode 100644 index 000000000..a9fef9bcd --- /dev/null +++ b/sql/updates/world/2012_02_18_08_world_gossip.sql @@ -0,0 +1,5 @@ +-- Fix mistake in Fallen Hero of the Horde gossip update +UPDATE `conditions` SET `ConditionValue1`=2784,`Comment`='Show gossip text if player has quest 2801 or 2784 completed' WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=840 AND `ConditionValue1`=2704; +UPDATE `conditions` SET `Comment`='Show gossip text if player has quest 2801 or 2784 completed' WHERE `SourceTypeOrReferenceId`=14 AND `SourceGroup`=840 AND `ConditionValue1`=2801; +UPDATE `conditions` SET `ConditionValue1`=2784,`Comment`='Show gossip option if player has quest 2784 but not complete' WHERE `SourceTypeOrReferenceId`=15 AND `SourceGroup`=840 AND `ConditionValue1`=2704; +UPDATE `smart_scripts` SET `action_param1`=2784 WHERE `entryorguid`=7572 AND `id`=0; diff --git a/sql/updates/world/2012_02_19_00_world_quest_template.sql b/sql/updates/world/2012_02_19_00_world_quest_template.sql new file mode 100644 index 000000000..76ab51f80 --- /dev/null +++ b/sql/updates/world/2012_02_19_00_world_quest_template.sql @@ -0,0 +1,14 @@ +-- Shadowmourne quest chain fix by nelegalno + +-- Limit quests to Warrior, Paladin and Death Knight classes +UPDATE `quest_template` SET `RequiredClasses` = 35 WHERE `Id` IN (24545, 24743, 24547, 24749, 24756, 24757, 24548, 24748); + +-- Quest relations +UPDATE `quest_template` SET `NextQuestId` = 24743 WHERE `Id` = 24545; -- The Sacred and the Corrupt +UPDATE `quest_template` SET `NextQuestId` = 24547 WHERE `Id` = 24743; -- Shadow's Edge +UPDATE `quest_template` SET `NextQuestId` = 24749 WHERE `Id` = 24547; -- A Feast of Souls +UPDATE `quest_template` SET `NextQuestId` = 24756 WHERE `Id` = 24749; -- Unholy Infusion +UPDATE `quest_template` SET `NextQuestId` = 24757 WHERE `Id` = 24756; -- Blood Infusion +UPDATE `quest_template` SET `NextQuestId` = 24548 WHERE `Id` = 24757; -- Frost Infusion +UPDATE `quest_template` SET `NextQuestId` = 24549 WHERE `Id` = 24548; -- The Splintered Throne +UPDATE `quest_template` SET `NextQuestId` = 24748 WHERE `Id` = 24549; -- Shadowmourne... to The Lich King's Last Stand diff --git a/sql/updates/world/2012_02_19_01_world_quest_template.sql b/sql/updates/world/2012_02_19_01_world_quest_template.sql new file mode 100644 index 000000000..2f888f08c --- /dev/null +++ b/sql/updates/world/2012_02_19_01_world_quest_template.sql @@ -0,0 +1,11 @@ +-- Dire Maul Book Quests + +UPDATE `quest_template` SET `RequiredClasses` = 1 WHERE `Id` = 7499; -- Codex of Defense (18357/7499) +UPDATE `quest_template` SET `RequiredClasses` = 2 WHERE `Id` = 7501; -- The Light and How to Swing It (18359/7501) +UPDATE `quest_template` SET `RequiredClasses` = 4 WHERE `Id` = 7503; -- The Greatest Race of Hunters (18361/7503) +UPDATE `quest_template` SET `RequiredClasses` = 8 WHERE `Id` = 7498; -- Garona: A Study on Stealth and Treachery (18356/7498) +UPDATE `quest_template` SET `RequiredClasses` = 16 WHERE `Id` = 7504; -- Holy Bologna: What the Light Won't Tell You (18362/7504) +UPDATE `quest_template` SET `RequiredClasses` = 64 WHERE `Id` = 7505; -- Frost Shock and You (18363/7505) Closes #4727 +UPDATE `quest_template` SET `RequiredClasses` = 128 WHERE `Id` = 7500; -- The Arcanist's Cookbook (18358/7500) +UPDATE `quest_template` SET `RequiredClasses` = 256 WHERE `Id` = 7502; -- Harnessing Shadows (18360/7502) +UPDATE `quest_template` SET `RequiredClasses` = 1024 WHERE `Id` = 7506; -- The Emerald Dream... (18364/7506) diff --git a/sql/updates/world/2012_02_19_02_world_gameobject.sql b/sql/updates/world/2012_02_19_02_world_gameobject.sql new file mode 100644 index 000000000..88a1f2e3a --- /dev/null +++ b/sql/updates/world/2012_02_19_02_world_gameobject.sql @@ -0,0 +1,4 @@ +-- meeting stone for UK +DELETE FROM `gameobject` WHERE `id`=188488; +INSERT INTO `gameobject` (`guid`, `id`, `map`, `spawnMask`, `phaseMask`, `position_x`, `position_y`, `position_z`, `orientation`, `rotation0`, `rotation1`, `rotation2`, `rotation3`, `spawntimesecs`, `animprogress`, `state`) VALUES +(245, 188488, 571, 1, 1, 1237.301, -4948.268, 36.02063, 2.495818, 0, 0, 0.9483232, 0.3173059, 300, 0, 1); diff --git a/sql/updates/world/2012_02_19_03_world_warden_checks.sql b/sql/updates/world/2012_02_19_03_world_warden_checks.sql new file mode 100644 index 000000000..3698c4613 --- /dev/null +++ b/sql/updates/world/2012_02_19_03_world_warden_checks.sql @@ -0,0 +1,802 @@ +DROP TABLE IF EXISTS `warden_checks`; + +CREATE TABLE `warden_checks` ( + `id` smallint(5) unsigned NOT NULL AUTO_INCREMENT, + `type` tinyint(3) unsigned DEFAULT NULL, + `data` varchar(48) DEFAULT NULL, + `str` varchar(20) DEFAULT NULL, + `address` int(10) unsigned DEFAULT NULL, + `length` tinyint(3) unsigned DEFAULT NULL, + `result` varchar(24) DEFAULT NULL, + `comment` varchar(50) DEFAULT NULL, + PRIMARY KEY (`id`) +) ENGINE=InnoDB DEFAULT CHARSET=utf8; + + +INSERT INTO `warden_checks`(`id`,`type`,`data`,`str`,`address`,`length`,`result`,`comment`) VALUES +(1,178,'07F223143C69271AA2A851FECF6DC883A9D3A7DBA6FE26CC','',710730,23,'',NULL), +(2,191,'C7D18F99DBC446A4B36E78B9130B6FA2E365B3D2D4199DF5','',28940,17,'',NULL), +(3,191,'AA1A8559776F873F26954F15E49E6041EDC2C3766AD87A59','',21826,11,'',NULL), +(4,178,'5F342A4D0EA9DB35F93FAE6E32670D810F017309817AA7C0','',676970,23,'',NULL), +(5,178,'C57BD89DD447131EA2083784AB4DA8BD58CF3E182F1D8AF6','',690106,23,'',NULL), +(6,191,'69AA85EFE8A1A990DA5ECFED4FAFD5B14F1D52EF2548FD15','',12905,36,'',NULL), +(7,191,'083ECAD073DE2D61E3564B4BF767C9D1F8F15AA0495F5A76','',41096,24,'',NULL), +(8,178,'C774D64EF60AD5A141FC56F3D02AE78AC147770FAE25D8FE','',3037164,22,'',NULL), +(9,191,'502C59CAFEA11E9584C13BFE75F85EB79936AEEE31B44165','',12194860,37,'',NULL), +(10,178,'4FBE8978A662428C616AABD71DA5562E4AC21F54BEB8ADBF','',3037164,22,'',NULL), +(11,178,'83D3F7FD7DCA144AD8219A6A4E20F0CFC6E7EA208C4144FF','',3033068,22,'',NULL), +(12,243,'','',4623652,7,'578B7D08578BF1','Pointer to realmlist address'), +(13,178,'00523153EE2298A8D80D7B26B7067CA7B26AC06FF374FE7B','',673210,23,'',NULL), +(14,191,'91BC368FA14A3FE3E13D0B1056F485F846925E613D8E8903','',12194860,37,'',NULL), +(15,243,'','',10010636,12,'8166443FFF1FFFD9565CD95E',NULL), +(16,178,'8FEFDBC58301AB0E0D0F6EBC5FBDA5ED9A7126873A9AB337','',682394,23,'',NULL), +(17,191,'B40FF92D4F092599EA9014C88B474DE4352C3F1635109882','',448492,48,'',NULL), +(18,191,'42B596FF923054531E4918DC39E08F8564FED16D559B494A','',29852,20,'',NULL), +(19,178,'24291D6733A7CEFA3D54C3BCCAE95D56D8365BAB42AEE1CE','',3037164,22,'',NULL), +(20,178,'6C4E321E2D5A153F2BB664EB6EEDF8D67FDE7ECC8076D087','',3990720,23,'',NULL), +(21,178,'FB649706C8F1AFF5990B5F3118DFE54FF6F9609C6991C161','',3045776,31,'',NULL), +(22,191,'D1B451C906B81261B048FD4025217245950C11660815367F','',28920,23,'',NULL), +(23,191,'40079A1083A6B57E3B713992BD395FB6650B631E4C4B8D4E','',29852,20,'',NULL), +(24,178,'3F8FEFE08CB358D6613656AFDB498AB8C599BA18B5574FB6','',682378,23,'',NULL), +(25,191,'EECA71B5536EE1992FD7825A5CCC4B7F9F3B413C0DA498B6','',29884,20,'',NULL), +(26,191,'B8786BFF2421ED1F1FB30F3F0BAF671FC1DAD5B3B33124C8','',28956,17,'',NULL), +(27,191,'BF0C842D635D9D8B3F6FF84EF6DF7C963C485EBAF02D17B0','',28920,23,'',NULL), +(28,191,'9672ED2A27C4972E04DF4471C95492C721024E241995170C','',36924,24,'',NULL), +(29,191,'63532B056020A261251BD24AB026BBC5D4468AF863136044','',17906,11,'',NULL), +(30,178,'7D38C80FEAB10B857A4A7BEF15D27A58FB43FD875E29C73C','',3990720,23,'',NULL), +(31,178,'B158752316672A90BF29846E7AD64BA4FD1699C638BFD3B6','',2299116,33,'',NULL), +(32,178,'4549AE7CA28700562D996CBC78FA7341DC05F644C01474E4','',3000288,31,'',NULL), +(33,178,'EE77806A4F5723FD9C6FC6F43308C8AB448E0A139CB43700','',690106,23,'',NULL), +(34,191,'046D6EA3E99E275F51CAA591BD8C478B6F964A3072018F43','',21660,15,'',NULL), +(35,178,'B1682CE919907AD7D8990F3D8272CFF24A996162565D52B4','',676970,23,'',NULL), +(36,178,'22E057649A8BF1D9672841EF47A4DA175AAC082FFEF059DA','',710730,23,'',NULL), +(37,178,'7BA62D5F5CFEB545D1AE646962F4EB9A91B93EF8FFD5D1B0','',710554,23,'',NULL), +(38,178,'702802D919D9E5C3FD42CA9188936C73E47F87CFA419025A','',3033068,22,'',NULL), +(39,178,'FDA6D997BFB8A991B57755633D1AB3C7E567A74C1EC09937','',3070052,22,'',NULL), +(40,191,'84F6BDD28490937867774E7BF8D5B78F68BF9EB43DE90F10','',477912,60,'',NULL), +(41,191,'5A5B4BA32BD937FF253016AE836DD44B794F8D05982860A6','',447736,48,'',NULL), +(42,178,'A243986665C7FCA1E60A9F209DE9431C3098D082DF1C4528','',682378,23,'',NULL), +(43,178,'7CC89374CE3A9C07DCD685006690B828931D60085EE5FEE8','',710554,23,'',NULL), +(44,191,'01F10590E6DFED79523D26C043D5424174BEF1011F3F4974','',477928,60,'',NULL), +(45,178,'C9728BDC4B77BAA7B3515AFD3628EDB0986DFA20B46917B4','',672746,23,'',NULL), +(46,191,'179B80E5E054521E44BA8F5978D5FC489CC9E514B350A3FF','',28956,17,'',NULL), +(47,243,'','',5417948,5,'7734FF2485','FrameXML Signature Check'), +(48,191,'7769A67D6E2460450873133B0CFF99B67A58CE6C404A17F8','',17282,15,'',NULL), +(49,178,'CF3896074EEBC0F93B539FD44E4D825227D4C1556B8F2279','',3990720,23,'',NULL), +(50,178,'88F2833B5267A71A0CA72509C40819B99283A6E556FD9038','',198,10,'',NULL), +(51,243,'','',8491566,5,'8B4D10890D','Lua DoString'), +(52,178,'F7229DF2D879A9E8D5BCEDCDC7046D75BAEE1C9D4DA41E55','',3638348,23,'',NULL), +(53,191,'AE78585CD862134059B13669FC416B8124752EC6471DDCE6','',28940,17,'',NULL), +(54,191,'B408E9F9B475E4B6A81F9B7F2E060824F618FFDABBFFE805','',13634,11,'',NULL), +(55,178,'A9DA016B83961F95097E08F2DEBE69517C7573FFF06D8C4B','',668874,23,'',NULL), +(56,191,'0E74160C242EF826D09BCE4ED535E9A9D251B1CD20E31891','',24812,14,'',NULL), +(57,178,'A58E4D44D952C1F9DB7B5E423167EE4C28AD02668C5B86AF','',710730,23,'',NULL), +(58,191,'35A9FC42ACBF3A147B0C8CF67BA04EC979C6534B20249B45','',28956,12,'',NULL), +(59,243,'','',5345746,7,'746583F9177760','Lua Protection Patch'), +(60,191,'1430DC4A627EA5FA2CFF9C010CE16022F259F81DB6047879','',13634,11,'',NULL), +(61,191,'85A005398AF851382267C01BB6FB04AEF2093213C20EC200','',360508,13,'',NULL), +(62,191,'96916CD89649027A9A8BBFBD28AE190CD5D590E24BBAD451','',13033,36,'',NULL), +(63,191,'056D57A5C1A46883400E1F69405750B23DE18C3032C3D91C','',27270,13,'',NULL), +(64,191,'87C641E1EDBD96D9F170C7BE0FA13F45611DCDF41AC02526','',41127,24,'',NULL), +(65,191,'1F378DF1E7BD99164DDC7401A98CA5E9551BD50B4A35D5AA','',34176,25,'',NULL), +(66,178,'B5ED443D6CA2F6095BAC8DAFDC8F3413F7B473916357C17E','',209352,75,'',NULL), +(67,191,'A2BC3FF01787A38CB88B3EF45C1CD97DA113157FC395D38C','',30012,16,'',NULL), +(68,191,'190862E5018F1428E5B12BFDAD08283ECD057B34AD722846','',41228,24,'',NULL), +(69,191,'6E0E55BE8690F64442E275559E6C9F8A3FDCAA00937D1C13','',49347,24,'',NULL), +(70,191,'B6FC4C07BB2CBE7C5C854CD99DAFEC0D1AE4101FC51460F9','',477912,60,'',NULL), +(71,178,'3B5955C3B498489869990F08A4CAE566A7D689C23990518B','',156,8,'',NULL), +(72,243,'','',7246064,6,'8950108B450C','Movement State related'), +(73,178,'F24317DAA28AA477996EEBB9538A89569ABF9B185A3EA4E4','',718842,23,'',NULL), +(74,178,'DA25A4134671325719833878E2556455EC4321A2207B6728','',198,10,'',NULL), +(75,191,'DC9490A7BEB43C64585E013B5260BE843D126EB3BCEBAC11','',50040,26,'',NULL), +(76,178,'4BB92BBD5CA8C192C9D0E1EDB6C21FF3F4A61ED1B151365F','',673210,23,'',NULL), +(77,178,'13E8DD1C9F5501A270A59CC4B61311F6D5D18DC3F2AA351A','',3037164,22,'',NULL), +(78,191,'346CFA39FF98198BDE1C23673FBF51A50CFF5ADED784F077','',17522,15,'',NULL), +(79,113,'0590FC57AB448975FA46C314A8AB75AF96DF0FD0A3D9FB23','Afd32uu',0,0,'',NULL), +(80,178,'E37D413DC96A92D3CEAB8A482B8F5397587A0E654C9A0166','',672954,23,'',NULL), +(81,178,'E7D5551799C2C7F0072BC3149A22F37D09EA1EB83F64C655','',3045912,31,'',NULL), +(82,191,'7CC5260578671130CA5B3392BA5CFD0F3DE0BE1085E556B6','',9977,32,'',NULL), +(83,191,'F44A40945F24385D089E040A733553EEFF92EFAAB0636323','',134968,32,'',NULL), +(84,178,'D3122CF30EE55310CF4A710E61B190D2B108227B746B41AD','',679578,23,'',NULL), +(85,191,'7E3CC1BC53477D84F05F623BBC94B9DE8D01A2607CA935DB','',41188,24,'',NULL), +(86,191,'DC06565CC1512B5A91A848E08BC4FBC6DA705F6503667852','',41127,24,'',NULL), +(87,191,'03DC47CDFBB14C5CF0D0010FA5424556F951585588A2180A','',29916,16,'',NULL), +(88,191,'29EC91C4D87891FECDED381CE65A86A259F00DD788833E4D','',174688,37,'',NULL), +(89,191,'31F024003681765368F6EFB667E83CE1D12799723AA99BF9','',685304,44,'',NULL), +(90,191,'6A82AC1D0BFEF5DA7385510CBC57189FACD42E45E0D2A65E','',30012,16,'',NULL), +(91,191,'3901FBD52655E12ADA4EEDED3B365B1DDFAAA925A140097F','',448492,48,'',NULL), +(92,191,'6E9991A25EC347BEA5813EDE0A842D746779C97606565B5A','',17906,11,'',NULL), +(93,191,'0AC9F2B104AC5AA9131FB14E669B98D30D056936625B0245','',27270,13,'',NULL), +(94,178,'A338B3DA78A6683CBEE08A63C5EEFBE1AF33BF54983D583D','',684876,29,'',NULL), +(95,178,'38759C29F2ACF42DA9D16EF35837A470DC7C42C3284B2A3C','',3049492,22,'',NULL), +(96,191,'F35817564FC39F4DB7994021352FEEB86E2FEE86C11B8DBB','',360508,13,'',NULL), +(97,191,'09FAC087283873DAEE0AD074ABF7DDB1B395F5CF6BC2141E','',28956,17,'',NULL), +(98,178,'87FE57916743AF3C97CC3B583B29E89B6E503D31D1747B64','',676970,23,'',NULL), +(99,178,'97D854645011BAD1F6625679511D78D1B7367A51EB0FCC6E','',668874,23,'',NULL), +(100,178,'12369F6F1B875FB5CC5E67445ADEAE2B295D196596679317','',0,9,'',NULL), +(101,191,'5034278808E93A3DFC9BEFFD8E180FEFA24DFC5056ED3BE1','',433168,48,'',NULL), +(102,178,'55EF16220A7EF3F74A9D895821610DFBD2A757FB05C792D5','',209352,75,'',NULL), +(103,191,'67445533AA0BB737D2F74C9258148C6C667794F0E3D07498','',45324,24,'',NULL), +(104,178,'AA8649100B17A9C5BE227F47F867FADE51AD242BAAD39821','',3045632,31,'',NULL), +(105,191,'85545FE9242B2474574EEBABBF452FBD11497073CB1E46A5','',41080,24,'',NULL), +(106,191,'9DACD6981681F53650B681EAE68065D26F4803682058709D','',448456,48,'',NULL), +(107,191,'96B74F1436A05E658E3282164BC3CBDF4DBBB2CF6A5B866F','',9977,32,'',NULL), +(108,191,'033BD6861DF7878DC9470EC2F699772BB2F3D5000490866F','',90202,13,'',NULL), +(109,113,'B797D0AF3164EE83167D5C054A511A5B209A70C6655C408B','IPSect',0,0,'',NULL), +(110,178,'D91A2764435C5091D3F9471AB8B5F397E609330294694488','',710730,23,'',NULL), +(111,191,'94EED02DCDB71789E50917DA401A03F4B91BDBEA050D8BCA','',3766400,37,'',NULL), +(112,178,'2DF33CBB544E2D5238FB591F2547AC507B4D8A652D789F2B','',2303444,33,'',NULL), +(113,243,'','',7860712,5,'742DF6407C',NULL), +(114,178,'81A74F35F0F887144D59F93647C18C70C5FEEF542A7F3782','',709322,22,'',NULL), +(115,178,'2E1F8A68FDDF084A950B786A1EE7E0CE43E62449A56F92A3','',3045632,31,'',NULL), +(116,191,'B1F8988B6664A90E79503FA5D843C3CB97BFDC23EB8C7690','',433168,48,'',NULL), +(117,178,'0277E26DE31814DFD675A59E526669E39080E033BAE88859','',0,9,'',NULL), +(118,243,'','',10714892,8,'BB8D243FD4D0313E','Wall Climb'), +(119,178,'09BBFC19FCADC69D6B5BF655A5BB6350B4A8120C3EB557D2','',3990720,23,'',NULL), +(120,178,'BF4ABDEB726B0060E74701C03180C3CB02170ADCB7DCB61C','',3049872,31,'',NULL), +(121,243,'','',9990741,9,'8B878000000089463C','No Fall Damage Patch'), +(122,178,'D259A46A6D1855C436BFC96FB9376BDCDF5E9FFAE8B4147C','',3045616,31,'',NULL), +(123,178,'F425A62A44097742D72A05669B6BE93AD9CEFE9E40D71E48','',3045976,31,'',NULL), +(124,191,'B134291F515D136B6576FFBC0133C7859755974611170D07','',20512,16,'',NULL), +(125,191,'125BE691985D8DB37068DC14D74EA2DA1260E4A63D3F74BF','',45324,24,'',NULL), +(126,178,'E06E3C5B356B34BA92F6765108556AD53ABB74B986D5810E','',3070052,22,'',NULL), +(127,178,'8CC87DFF61F2EC82DE033865C9879010D94E1614369FE286','',710554,23,'',NULL), +(128,191,'E1F5233450FEFFB6F0E8F2B17683047A485828FEDD3E5B80','',448456,48,'',NULL), +(129,191,'31BA6EA4DF2362676AB71F4CB60B0D40FA51A3AABD25D5CB','',36924,24,'',NULL), +(130,191,'C14630E1D519EB85C254C536FE81DC490977E869BD5CD884','',12985,36,'',NULL), +(131,191,'B337F892EEDD52A5B978C116A19D927134273626EFC4DAA3','',17890,11,'',NULL), +(132,191,'D97560108AA21A487EC9278759F7615BFA304A933776A201','',18680,35,'',NULL), +(133,178,'DA59505BA61459508532CBEAD246DCD2C8E7BF5C6D3CE676','',3037164,22,'',NULL), +(134,191,'5803CA69E5B7F1DF08D95219894D75F52EDB1AD429E562D9','',174688,37,'',NULL), +(135,178,'8A1099E19139D91573286DBB3DED2CC093A99FD178F7FEC8','',3033068,22,'',NULL), +(136,178,'0331B438B085F55C06F7F697160845BE953D9CE789AA62A4','',3000288,31,'',NULL), +(137,191,'E844078A5671FF7DB0621E7F1C7EDDF9C92F5A9FA0477FCB','',41023,24,'',NULL), +(138,178,'AAD7F47B231861913F353341FD26E5AA89AFB586FB6A5366','',672746,23,'',NULL), +(139,178,'136DFB3FE66D2830DF46EE155FCAEADC9624FFE1410088DA','',3041472,31,'',NULL), +(140,191,'C6015A0D5C9109768BA4233639A51F163CC7ED58749E5026','',25724,20,'',NULL), +(141,178,'9C668CE4D328EEA9B6AB7AD5FF54169289B35B230275A43C','',3049872,31,'',NULL), +(142,178,'FC3C95E71F968C46BD5DB5C9EF9B0A5BDCC5619B805046F5','',2299060,33,'',NULL), +(143,178,'FBE3808C0E36BFBC1D1F5A0E508CA89E81E550CD2FDEEC48','',149,5,'',NULL), +(144,178,'35A8252DBC65514E858256C497141153812EE61C724BF5A9','',710730,23,'',NULL), +(145,178,'CC79AA9AE29A52A998181D183D38974221B8BAC0AB534E7D','',0,9,'',NULL), +(146,178,'B89F25A249D295580E649F5ABE0C65EC24401F4889A4FB16','',668874,23,'',NULL), +(147,178,'742A0A9997B9E857C355AA75797466506BAE73D44D26399D','',3037164,22,'',NULL), +(148,178,'E7975701601B2FDF8262098521B7BB4FF5CCC484F8E919E7','',3045776,31,'',NULL), +(149,178,'43E81BE830F169F4EDD23B84ABFA9D15EF12C978FE134346','',60648,56,'',NULL), +(150,178,'66CA9E464A2122E301A72FAEF13A4853D8CB1A45C177E854','',178504,96,'',NULL), +(151,113,'0A3C294B0799FD2C9EC17C1CCBCD174A51B6A2ECC62FEF17','IPSect',0,0,'',NULL), +(152,178,'6E9CE81BFCAF0C250705FCC599981D2D9E4D474A7E857B37','',2299108,33,'',NULL), +(153,178,'8734D6E081D5C993DCE8161CFDFC6197F39A487E4083A3E1','',149,5,'',NULL), +(154,178,'A33355AF7B5FF3CECB3A6059F6621F30AEE695D69421EA2B','',3049492,22,'',NULL), +(155,191,'BF8CEA63013511BDE0B551DAAC492DFBB9608645140B88F7','',29916,16,'',NULL), +(156,178,'8D5D5E99EAB2ED21A104913B05D6BD7A8E63ADA56B66CDED','',3022016,31,'',NULL), +(157,191,'778256BFEF82EA60C4E0F25083655FB2BB75B83FD60A9C06','',18680,35,'',NULL), +(158,178,'43FB8007D7DD7B01FFBEEA3EF9D0242778565544281EC761','',0,9,'',NULL), +(159,191,'94DCF5D21FE2106F5303216C14AD55EEDC1B19FDC91D5F76','',28704,16,'',NULL), +(160,191,'7EBBF90F7D8462D1453479DF9AC5943AF483FE2828C74FDD','',477928,60,'',NULL), +(161,191,'A171148491E099B12CCD1708B784D8C3B09737772C7780C0','',401992,14,'',NULL), +(162,191,'5350ACB75F9FA498FE0D2A371649C9FD9716BDDE2C32F5FB','',13634,11,'',NULL), +(163,191,'85E53280630956C58D4CA7FD8DC5FE73C9A2A03314DFF294','',45223,24,'',NULL), +(164,191,'391BC8A81D4EB6D526BAF0DC3468CAA36C9207B82E194B7A','',130380,14,'',NULL), +(165,191,'0F88FA5CD9B9950F850C18FE76C948FF43CDDE3E75638FF1','',17938,11,'',NULL), +(166,178,'EB63FC60164AFF92726DA658882BF1CE47CF0BF6C80B1B97','',690106,23,'',NULL), +(167,178,'E30B2494142B416BBE95DA3DAE4A82CBDF3A020715F10E8B','',4011280,23,'',NULL), +(168,191,'6CA1C19D0E9191CBC9CA3D5BC3CF1D19764D8F17C6B54AE4','',59620,13,'',NULL), +(169,178,'4730B7A7EC70544A688211A5C754C357A090116092D3EC4D','',682378,23,'',NULL), +(170,243,'','',10000022,6,'894644894E54',NULL), +(171,191,'713A7B79619AEF3C47E44102F86EDCE0D6AFBC5ABE87F861','',13538,11,'',NULL), +(172,191,'575F1C6AF7C71085C7D9CB2291844D9F2DA3B71391C0B941','',36907,24,'',NULL), +(173,178,'296F233E4FAC4CF419D5FBF2701AC4D5AA0866CB4D0DAEC6','',3045976,31,'',NULL), +(174,178,'933C1A228C99E35DF309838B25B7D5EA3A8E961E81D81D32','',673194,23,'',NULL), +(175,191,'9EC125252C3738478CA942DCB59030097194B284A9162B32','',59620,13,'',NULL), +(176,178,'6665F3FB8DC6BE71C152C3674B5783D6E57FE8BF796D190C','',3634252,23,'',NULL), +(177,191,'E120DD63042FEFF9E7FCEC0CA44D2544F03C5D4CDBA1C008','',12985,36,'',NULL), +(178,113,'09BDABA6CB17BE561B4104124A3D0266C858D194A8765198','drvsys_mon',0,0,'',NULL), +(179,178,'3AAE69E7088E4060EA32EF95E9B6D9532460F5B84EE4EC80','',684876,29,'',NULL), +(180,191,'990D4E1C2D63C8E447F034642686D57B727064E3EDE13B00','',448500,48,'',NULL), +(181,191,'E88F31BDC5513216CF3701CAF8BE954CCC7EAE0E7AC7D942','',594348,26,'',NULL), +(182,178,'81229C1E56FA72E01B52E8CBB8BB5F55ED48A11B72E7729B','',710554,23,'',NULL), +(183,191,'B4D0CDE7D53493A1549328F711013F07DBD3A9BE88DB2EF9','',685304,44,'',NULL), +(184,178,'D6CA6F94FF248F722F97037C1AE7C8DE0191D5F4D1E3A5B8','',156,8,'',NULL), +(185,178,'9C9DF1E868BB33D43676F21096C4F75759C0807096EEB886','',60648,56,'',NULL), +(186,178,'1C79B3B5A74A4F09A1FAE19BB15CDCF26B5F917861071F1C','',198,10,'',NULL), +(187,178,'AC1AD3E831A4C758858350A8A197A24FE82583F4B0E39A85','',3049888,31,'',NULL), +(188,178,'56E4980485E3129E94F370E7066E80B07141C4A669B9FC0F','',672746,23,'',NULL), +(189,178,'C21574305E0377A3D2B72D1E1546B9D62DCFA8B1A4405F16','',3638348,23,'',NULL), +(190,178,'AA74121AF835978BC1C1BB402A8B7388CB7C075C1227C253','',3049888,31,'',NULL), +(191,178,'D6457A86DFADF9825D6093090AED2A807FE7DA6ECF5922AF','',3065956,22,'',NULL), +(192,191,'1BAB7E6B5ACBEED8F54B667EDF13A385B9E146C0C50D9FB7','',448456,48,'',NULL), +(193,243,'','',7517484,7,'7518683B010000','Follow Unit Check'), +(194,178,'01000FEAC61ED76FE04ED1169C40289D96C71A1564E38FCB','',690106,23,'',NULL), +(195,191,'F095338ED87C658C916CC604A427F4ED95309C4A07B7898C','',34176,25,'',NULL), +(196,191,'800E120187DF74A231722FB887B3944AD16A703FB8CB9D39','',28920,23,'',NULL), +(197,191,'2CFCE981C322A54724E1418B6A6D1896B95D584630EEEA43','',38300,21,'',NULL), +(198,243,'','',5081862,8,'6840AAB600C60200',NULL), +(199,178,'481751066D6C97AD5EE90173E8ED107BB1C9FD873B0CE55A','',3037164,22,'',NULL), +(200,178,'7FC57D49535798CDA7E4DC5DCEA2E085AAB9A68BF7F9469D','',149,5,'',NULL), +(201,191,'33357C112DE0195F013FAAC4D57AB1BE77417934CE03A2B9','',3766400,37,'',NULL), +(202,191,'BF8AC678DC3CD354BADBFE46C9173D34CC84D13302190EBB','',21826,11,'',NULL), +(203,178,'4E2F9721D52A7552AE2728B9695F1523DD62DC0569237C3F','',2299108,33,'',NULL), +(204,191,'9F015E7D8A11F30AA1954D9FEA7142D0247E3C09FF2BFF72','',12194860,37,'',NULL), +(205,178,'1EB5AD39B94DB5CDC3294DF49FA589DFBE2C674D07E4B211','',710730,23,'',NULL), +(206,178,'E9D67F07E035A64B89C9E91614DC1930FEF61DC3A5C1BBA6','',690106,23,'',NULL), +(207,191,'36411C2FF2C3AC51B7F6A6B8DF61DBD4E5895C27438847BE','',59620,13,'',NULL), +(208,178,'A77F30CBB8057E0DB37782367C8462FA98D4DB21DE936ECD','',3049492,22,'',NULL), +(209,243,'','',7452688,10,'8B81CC07000025000000','WoWEmuHacker Injection'), +(210,178,'A8C806E1FB7CA3625E6BB6F5E4D9E2BF0EBDBE70BA7226F7','',3049872,31,'',NULL), +(211,191,'B3DD04807DEA2679045F4F197BDDAED5C7CCEEFE19622B43','',360508,13,'',NULL), +(212,178,'B075C8B4D8C5D83FE703677319491DC816EA5103901B44A8','',682394,23,'',NULL), +(213,191,'53DB506C0341B50BEA3897E2E3C0DD74C2CA2D8F5F34A2E4','',59620,13,'',NULL), +(214,191,'E112F38956124FE0F48BF569F5E81B40E293DC6E16B544D6','',17282,15,'',NULL), +(215,191,'0363EF2B1AAE09E6C2B1FA555E706F4EE094BE678DA27598','',3766400,37,'',NULL), +(216,191,'EA256F01B6340C99E27611B39C5ED28CF2FA202436F0972F','',49564,24,'',NULL), +(217,178,'A86C95C4E58495A10F5F1C9B5B62D3365132E8DC62863E8B','',198,12,'',NULL), +(218,191,'56DD8D99991F83AFA2E169315B395BD388B248340E9C64D3','',30044,16,'',NULL), +(219,191,'684B23E010C3D6B88CC12BD9F0B6B0CE00D692C71BFB84A8','',28940,17,'',NULL), +(220,178,'83AEEFCDF4C2E80B18DDF93D99120A89F916C19206D257AB','',668874,23,'',NULL), +(221,178,'D68651921F5CD387C7E860FB7C3B143409735748E3B2FB7F','',682394,23,'',NULL), +(222,113,'A4D501A9DB9D84BD8695A8BF61FC853BF434D2D4B352C7A0','HideEx',0,0,'',NULL), +(223,191,'5E77F12C032D4FEF559F9B837B85BDB9D95ADB10C9F56649','',448504,48,'',NULL), +(224,178,'F08406AEDFA8F19B6FB7C9ADDE0BFEE82CB0D2E275593150','',2303444,33,'',NULL), +(225,178,'AC0EC72522ADA5B2BFFAFAC92D6D0A0225E1D5C727CDFFA7','',672602,23,'',NULL), +(226,178,'4D1A7D1C88AB04438510E3255184E51EAE2036BB09DB553A','',700714,23,'',NULL), +(227,178,'68BBC36F75DC763B573DACAB1D6D8F70E667638AA894BEE9','',717898,23,'',NULL), +(228,178,'2AC3C23FBDE2C1EC46C9ECFF71BD7F603F17C9DFC1328D1C','',3638348,23,'',NULL), +(229,191,'C365E9FE00580EBB14EE863A5CE3C8139B1A59A610520AE7','',3766400,37,'',NULL), +(230,178,'DB2A0451B9753100085C9D149B61CE47A195D77C8B709143','',178504,96,'',NULL), +(231,178,'0871F69205FA62C74C2DDE200A3911FC3E41A4FB8BAB9817','',682378,23,'',NULL), +(232,191,'0017307F2FF889462B0FA06018D99EB1F847F189B6CC9B99','',21826,11,'',NULL), +(233,178,'0FEFCD6B0BF8C2816A9259AB5FD7B89231AEB8D92DE53D26','',3045356,22,'',NULL), +(234,178,'87EAD79656133B3183C2E452886D8F00C5EC6C9D741673A2','',3037164,22,'',NULL), +(235,178,'C2B6C5E19FA98D121B2CDE51789BD2883A324015E7D131E0','',710554,23,'',NULL), +(236,178,'B6F3A7D557A3E3BC4833C3D9B6B0B0609255591CC8AB3B65','',3022016,31,'',NULL), +(237,243,'','',5283280,12,'558BECB8084E0000E8731DF0','AddChatMessage'), +(238,191,'AEA87B23CD9463E9693B6C053C1D9030F8E229DA308DBF29','',90202,13,'',NULL), +(239,178,'8C16C7E8EEAD49AE67E4E91E229FFBCE2F6590A48348914E','',3049888,31,'',NULL), +(240,178,'7B2DCA97CD348E45490C288EADE9303CE270CF57F28EB1E4','',690106,23,'',NULL), +(241,191,'BC10B10BE398F2397FA6962C4E59C8CF11FDD7158EC222A5','',29916,16,'',NULL), +(242,178,'8E53EC1B8ABE90C9A5C087671DE0A3007BEA4488EE5415D0','',3037164,22,'',NULL), +(243,191,'65B5CE07A794164101F7E379D21A7A544EF1EC2A3A39A2D8','',27270,13,'',NULL), +(244,191,'C6C8597824F249180A53196699421ADF7857A5C4E4F80D6F','',13033,36,'',NULL), +(245,178,'FE677759E719178BC5CB49DA252D9B635F76030FC4C9876C','',673194,23,'',NULL), +(246,243,'','',5265823,5,'72118B5518','Language Patch'), +(247,178,'BA2D161EF412084B0229A08E64D5A445C4E9F9F2645535E5','',706314,23,'',NULL), +(248,191,'0174B647A535F206711D3EEEF08D3F421BCABD7016A2F103','',17282,15,'',NULL), +(249,178,'5F5F754FD6E7BAC9650B715387646CF992813730A2BA37DA','',2303444,33,'',NULL), +(250,178,'D2CC7F98209E9A9BBA483BD1E9A916E40EB971EE2129AFF8','',3990720,23,'',NULL), +(251,178,'E8C741CC79005898FFD0026821F61A2E4E67C695C6E1CE1C','',198,10,'',NULL), +(252,191,'23B364A9012EF40A39EC4D04A91F9B60FC7EF7D85E3F240A','',18680,35,'',NULL), +(253,191,'C9363F808D37F13FC09EBB7F700AD09EEB27DA046E41FD52','',36907,24,'',NULL), +(254,191,'2D92FC5B8603E18F50D9CAA0922F5C7BB89E42A4656ED2D5','',3766400,37,'',NULL), +(255,178,'EDEDBC5B1A3D92D2A91192118898FDBF840C967C82968D70','',3045912,31,'',NULL), +(256,113,'BFEF06E80472106B57B15D711F94A25243F6ABA7FE354C95','ndis_x86',0,0,'',NULL), +(257,178,'FB20B0EB9ACF571FE37C6B69CBE86F7906F96B996D7E5EFA','',2303444,33,'',NULL), +(258,191,'917AC1C48C1FF354FD594A3705C70A2C356FE981275E7FB5','',22792,25,'',NULL), +(259,178,'48CD29D8B39DC07B0FD071FD8C643E07A8FC2C9AFC2A3083','',3045356,22,'',NULL), +(260,243,'','',11154396,8,'D893FEC0488C11C1','Jump Momentum'), +(261,191,'FB13A8360C8E23B83ED7309625A7EFBAEE7DCF737068C5A6','',174688,37,'',NULL), +(262,191,'3C8D85F85ED5DD0354561F84EACA575123DE05EE941C28D2','',56063,25,'',NULL), +(263,191,'FBC20EEA52B5882209BC016EC14818376CA7BAF28780BCED','',22792,25,'',NULL), +(264,191,'210D85A84F7BE48F3EB427E0CBCCD9C146320ABAAB5E28D8','',41096,24,'',NULL), +(265,178,'953107F9F718795B6DF9E5E5BEE0EA949800CAD0EB71F891','',3037164,22,'',NULL), +(266,113,'FBBA36D0FC5434D12EE1509E148FF908D51F18719CCBEABC','IPSect',0,0,'',NULL), +(267,178,'82CB32BA2A05B228F2F8D0313C185EB6FDC50A94340F40C8','',209352,75,'',NULL), +(268,191,'079172B91B1768A2650A87BAB06AF700BB4C9A0B5E5B983B','',17522,15,'',NULL), +(269,191,'881751DF112F817E799953E00E94543DA4610968437DB7C6','',12194860,37,'',NULL), +(270,191,'9A47B274EAAC888FA2007B4EC0623580365458E3621CC416','',28956,17,'',NULL), +(271,191,'77344CE014111FAAA66DEF35B670B2E76AE878B054F85285','',61874,42,'',NULL), +(272,191,'0A74CBD8DFF245DA5E8691C1174F037D7ABE823E265226AB','',685656,44,'',NULL), +(273,178,'0E13ADDD413B679E2984060D929440064FAC308FC2B90742','',3049872,31,'',NULL), +(274,178,'D0D8CE5001596C6F4A766FE94726FE7E337F42469CB96CA1','',3065956,22,'',NULL), +(275,191,'313C58F8401B47F716B220B88411CAD0E85966D95B301591','',13033,36,'',NULL), +(276,178,'ACBDC68A4D748C48ED1180DD3DA52632EA6FC275BFC35D5B','',0,9,'',NULL), +(277,191,'BACA83A742B9E09CD07787BC6B50389707EA94C41886BAD0','',448504,48,'',NULL), +(278,178,'549B42D266E7F17B7F30B72E301A9CB3C5E3865DE9B7E90B','',60648,56,'',NULL), +(279,178,'86DB854557D75BEEE7DA820FCA15669B08C760E8B165B06F','',3037164,22,'',NULL), +(280,178,'02D5FBD9E30D43ACED0EFD00CF16DAA69EDD262C292136AB','',178504,96,'',NULL), +(281,191,'B9D920131EFC38767012340CF0FFBFE154DBA28E6EF3B859','',61874,42,'',NULL), +(282,191,'96E6CAE70AF690F5D552E0948C29CA9AA527DEBF9731B16B','',20512,16,'',NULL), +(283,191,'375B22B4990997348A8AEDD53319897BE196398B4F1DBAC3','',30012,16,'',NULL), +(284,178,'932F4622AE9F1B3990900F1F88375FA1DD7C238F7C6133C6','',684876,29,'',NULL), +(285,178,'43583C7BCCD9DF14C64CC84710BEE44DD30E199F579890AE','',3049872,31,'',NULL), +(286,191,'97CF98F0BCABA04BC2BAD40FBD4EBFB3C1FD8A7139D5C9B9','',433168,48,'',NULL), +(287,178,'97A0E0F8F8ACE7F1E6492DAFADE8F45B366446E79C1B0419','',3049452,22,'',NULL), +(288,243,'','',5284488,9,'7507C7451400000000','Language Patch'), +(289,191,'C3546D16052E0DC1838E7A6E18936B88CC8A40C2AEC0BE3B','',21826,11,'',NULL), +(290,178,'4179D6BD8C2F11AD5D5C103A7877504074009AB53AE4D8A6','',3045356,22,'',NULL), +(291,191,'2C360CEAB996C8D6E5DE3FFAC30E412DED48E7814D1CE110','',20512,16,'',NULL), +(292,191,'6F1486BE58078BD453F1B249947BB99CB8E17E9A355CE024','',41228,24,'',NULL), +(293,178,'924F4631DC3167BCFAB02F92DDB49A871DA0C55122EF9EB8','',0,9,'',NULL), +(294,178,'411029C5B28D942ED3C7BC1F4299162D874838A661410894','',700714,23,'',NULL), +(295,191,'B9093BAED730E86AF004119B3B7258938C56902915C2E8BA','',501956,48,'',NULL), +(296,178,'63BD2D7FF6C5442795361031E5768C396A37AE38AF98DB11','',668874,23,'',NULL), +(297,191,'754A2FE56037B971E128FFAA669032C511BDA3A62524CE03','',28956,12,'',NULL), +(298,178,'9AEFDCDB62EBC2DABD6CEBF8C411C1145274FCA7CED890CB','',3037164,22,'',NULL), +(299,178,'3AC57BAC3B782AE5ADBB899CCC060D4E8F66E5217F7DF654','',676970,23,'',NULL), +(300,191,'2F0D9702A58D6D5A8599529A0A816AA101AFE581D98416B2','',56063,25,'',NULL), +(301,178,'77804219E627B4D38C9F95194301A895180B598AEFA9963F','',3022016,31,'',NULL), +(302,178,'0D1B99EDC8E458705A88E72F7FDEEE9233DB21290A0098E6','',149,5,'',NULL), +(303,191,'BB795B4069F985BF44C7418DE264C3B0E9BA6D61A116FF81','',90202,13,'',NULL), +(304,191,'5A6EEBA1E6B9EE71BD4A5F63014E9928302C36FC806DC796','',3766400,37,'',NULL), +(305,191,'BA5777AF7FFF3895935669878D662B585912A759A2DFCE68','',24812,14,'',NULL), +(306,178,'5E690DB1AD8910886334158C6D4452FA2CE896634BCDDF40','',580768,52,'',NULL), +(307,191,'42A8F651F55F697E783ADA1959A2833276F970F1EE0410C7','',41280,16,'',NULL), +(308,243,'','',5296496,12,'558BEC81ECE80D00006A0AE8','SendChatMessage'), +(309,191,'445A6894B8C1838462D7D0D29FBE6BF815B5E6C344971349','',31924,23,'',NULL), +(310,178,'C010786A38F396503B7411FBADA0C1A68795F54A7AAE228E','',679578,23,'',NULL), +(311,113,'E3185EE4428291F9D2E4080C2EB1B19ADB005AD26EF0A993','IPSect',0,0,'',NULL), +(312,243,'','',7739760,11,'01BE80000000E805B6FFFF','Jump related?'), +(313,191,'1995FA3235ADA4B25232DC6403E7463A8D1864528BF9FDD4','',12905,36,'',NULL), +(314,243,'','',5124558,5,'8BF08D4608','GetCharacterInfo'), +(315,191,'30A26827798B7F1646003A9E846E8A9A8FF10A9DF926825A','',49564,24,'',NULL), +(316,178,'A567BBE4CA9D8E976083024E8D68903CF15CEA88C47C9961','',2299060,33,'',NULL), +(317,191,'BEA7165D7DD8E24E31B1C3D791A47A28731E1BACD1189A17','',24812,14,'',NULL), +(318,191,'0971A7CEB84D392670C7B8CBB61776762C25259D8E772CA5','',13538,11,'',NULL), +(319,178,'13200A59A28561A413FADAADFFFE4521A209CB691EA199A5','',690106,23,'',NULL), +(320,243,'','',5090917,8,'E886EE1D0083C40C',NULL), +(321,191,'56CABE081991356465BDE1DA3B8DED099DF9B6E746D1B531','',25724,20,'',NULL), +(322,191,'F98469C704F8B8ABC1A251EF8FC1E4CB5CEF1E007BAB5EA5','',57602,42,'',NULL), +(323,178,'6A64BF5AC652747B47E0B8E6593B7EEAC1EF38E0A84F4F5D','',3049452,22,'',NULL), +(324,191,'978BCD17BC9C81B05A2F0A50EC2CC206EC5F6AB1FE40D38D','',28956,12,'',NULL), +(325,178,'A28EDC898CEB14FB52591754DEF981C7168DD2421D0742FA','',3037164,22,'',NULL), +(326,191,'35E88DF07F0D48A0B7ABD53F4865DB762E6935529DC826DF','',360508,13,'',NULL), +(327,178,'BF1FB7E4C3CDD5D5A93AA1B24FC822AA5537DBB59F696818','',3037164,22,'',NULL), +(328,178,'343F1AFF6DA7A967D2DB958C608A6E2A19F83E862F8E3954','',149,5,'',NULL), +(329,243,'','',10694516,8,'2F549A416F12033B','Wall Climb'), +(330,178,'0B008034F97BD411A9F900D87578258AA1B79873850BC12B','',3049888,31,'',NULL), +(331,178,'C5A35B72E6BC604BAC9AA218908B3747D6850769CEA79C0F','',2299092,33,'',NULL), +(332,191,'FDDB2AA7F8884C8E3A7ED646B3E9E4AF5A8C0704130C39A7','',29852,20,'',NULL), +(333,178,'F57343CEA7133DE6469B1CFD1A749845D553B8D806B2BAA4','',3037164,22,'',NULL), +(334,178,'565A63583AC736E3CAFB95EE5AF9A64D3A7D3C3A8B234121','',3045912,31,'',NULL), +(335,191,'E26CF0E2ED92F608A80733CE703D7EA2C3DB83FE46182519','',3766400,37,'',NULL), +(336,191,'2F44EE3A34EFF98303B3724005EF3A8AC89CB25F9CA1B8BC','',12985,36,'',NULL), +(337,191,'C32F7CDB33BEF7B3093262F89263884DBB44E57D74D646B7','',12985,36,'',NULL), +(338,113,'2357AD2012CEBA72283F93460AC5FF55E4E5719A5AB9F5B9','drvsys_mon',0,0,'',NULL), +(339,178,'1C1595A1A64016D8725619CBC2FC7ABD41835320958A97FD','',676970,23,'',NULL), +(340,191,'DB5765A8B8D5F636D619E44669E9D3EF968BD8011C5D6999','',36907,24,'',NULL), +(341,191,'70B78734AC394D83D45427E0B7C88351E9BB108ED59C7E71','',37136,40,'',NULL), +(342,191,'85F2A5072D2D7557155CBF5157CAA460B19470DEE8AF96BB','',22792,25,'',NULL), +(343,243,'','',4609669,5,'8986100F00','Login Password Pointer'), +(344,191,'6C33FD80565B2860A76C87BB772E794E2FF444D813079A2F','',685656,44,'',NULL), +(345,178,'F09BEAD15FDEBD09240316D9E2E736028B54972B13F14E5E','',673194,23,'',NULL), +(346,191,'302E114D921D40EE54585BD9D63B9BDDFF7A2BD4D678DA97','',30044,16,'',NULL), +(347,178,'24807D7810C58A4B9A070A21B8AE50A0385DD4B4C6BD8B6F','',3049872,31,'',NULL), +(348,178,'B6BDECA858773B6F995AC6496923F5D0CBFDB1F76DB29C58','',198,12,'',NULL), +(349,243,'','',5296823,7,'75166824020000','Language patch (speak all)'), +(350,191,'C125EB3FD1B222ACE1B518959D96C5AC83EEAF109E9C6D20','',12194860,37,'',NULL), +(351,178,'8AFF28C3E6367B10340FB963B093AB52E61B267C541D5659','',2299108,33,'',NULL), +(352,191,'734D3EDDA69D9DD307032245FA0806456E2F02E90C2291E2','',36907,24,'',NULL), +(353,191,'9CB5A848D90B7FA4F58801ABD8A68EF8FDF8C602063C2CD6','',13033,36,'',NULL), +(354,178,'C8BCF785F8B7118D0270016E620E2C3DF6802E034471E5E4','',3033068,22,'',NULL), +(355,178,'8FB282098C8BB4EC10C8398E44C630677C6E2785227E31D3','',0,9,'',NULL), +(356,191,'2381BB2B613C58C364E962738335EBC2F3EFF81009DE49E4','',37180,24,'',NULL), +(357,191,'AA2A24A7C90D149C7817640B0D2D46C8A4B4D52146837605','',501956,48,'',NULL), +(358,191,'6815D749CCA8C1738A5F3236A737F0B70AE037E82D46033A','',448500,48,'',NULL), +(359,178,'F9F131F27BCC37FEF638FB8EDDAC29400652020C290D4F75','',676970,23,'',NULL), +(360,191,'319CBACC4CD2E1F54F8C8FC41EF44A3A9C492A652B00C622','',18700,32,'',NULL), +(361,178,'A4A7DB31BF51180F1ACFEA6C0E59AC84B43D022CB4BB817D','',2299116,33,'',NULL), +(362,191,'0DF639ED45B0C578DD616DD191014727A3C22C346E9FF73C','',50040,26,'',NULL), +(363,191,'72944B7FED63C1D2FC9D2CF6A07B5788731BE2B02215CEE4','',447736,48,'',NULL), +(364,191,'9148E18CF9213B25197C247F08CCA4C0DC60FEA73E3A247C','',13250,15,'',NULL), +(365,191,'ADA39A6A805BDF59271BBCE21734E8F28182164563CA15AA','',29916,16,'',NULL), +(366,191,'D5C852D85FA4393D027615506B7DEE07A1074AA4633019D8','',41023,24,'',NULL), +(367,191,'D06EE8DDC2115E5895E96D26A2A2F11FC566297D1D21BD26','',56063,25,'',NULL), +(368,191,'3AFE3B981D50B26FCAAC9DBE5A4BCB24F5BC3E9348AAA04B','',25724,20,'',NULL), +(369,191,'058E826BD75C26BACE712DF9D67B0A751896515802E9DDAE','',501956,48,'',NULL), +(370,178,'6E4C9CA0F7140E32D9284AF2E0EEB76419696771D4DDE887','',3634252,23,'',NULL), +(371,178,'29E43B1309ACB344AC777636BE838F0BFE6A04570B7FB09C','',700714,23,'',NULL), +(372,191,'5B7AC53977D57C5756A2F61582DD386EC93F5FE180FAB5DC','',27270,13,'',NULL), +(373,191,'22BF8D63A306178F368016E4657CCFCA5B2B21EBC90B8DB2','',50040,26,'',NULL), +(374,178,'1E8729EE000CD5BD8BABC49C368E0FF5AC08BC2B30921BC4','',709322,22,'',NULL), +(375,178,'8A1304B9AB2579F392F92D8A592308728EF76B26AE258A41','',4011280,23,'',NULL), +(376,178,'8A90AA547378BD5930D24FC415AEC08EF52E29B22073335F','',710730,23,'',NULL), +(377,113,'4BBF42A918109CC23F231B8E657076A213601AD681C032D1','HideEx',0,0,'',NULL), +(378,191,'06D9E92AE3953D13A0AC5FA31EC24B16C6A2260E2D32BF8E','',41096,24,'',NULL), +(379,178,'D4D3A9950FA07FAEDAD0658F9128007ADE282C043210A201','',683146,23,'',NULL), +(380,191,'94530FBCCC455105E8BB67E5B19BE0A4534A6F39A1201B52','',13291422,37,'',NULL), +(381,243,'','',4198410,6,'CCCCCCCCCCCC',NULL), +(382,178,'2313AF1E20F446936533F9440B220BEA966D9EB3A0502DCF','',178504,96,'',NULL), +(383,191,'F982BFDF01EB3BC6FFB70E897BFE21376232B2EEEFB25E58','',20512,16,'',NULL), +(384,178,'26308A71C6F483CC7795A01A2F2CF7E7EE97787C12CACC52','',2299108,33,'',NULL), +(385,113,'368334F9A3A549DFD3ABC9793E4EB83E837AA43F010354D1','ndis_x86',0,0,'',NULL), +(386,113,'5DA702DF95570780875ADB4C64259E887CE0A867D9B67711','Afd32uu',0,0,'',NULL), +(387,191,'B51E8DA25AAE556552404F5172642D0808A89E2AFE870B23','',694376,44,'',NULL), +(388,191,'4748EAC0350B1B56D8549157AAAAF4FF35438078A7E37AB5','',34176,25,'',NULL), +(389,191,'FBE20B03C75572D992273F192CE72CE78A65E6764BF8E6F6','',36907,24,'',NULL), +(390,191,'D8C1B9DEF3CA9CA59C5B827F055729B636FD55BA6242F9F0','',694376,44,'',NULL), +(391,191,'448475EBCA685E5A4ECC5F810740C9181825B49613CDDDA8','',477928,60,'',NULL), +(392,191,'2AF2DEE0CA5F307895E5773A083AEB862EA3D5210E037F06','',41080,24,'',NULL), +(393,178,'1708C050FF0C98DE59FE8F070273D80F9C1A612D336AB9FC','',3049452,22,'',NULL), +(394,178,'ED6BB184C9DD307229A023C1905E6EE73981D3E088D69FE6','',676970,23,'',NULL), +(395,191,'EB63A86D51668323A18AE2F8CE2BDD1ADAE57375B5F76C6B','',45223,24,'',NULL), +(396,178,'5837373EE8D4CCB5687045C04A4297450ACDE774FE973917','',673194,23,'',NULL), +(397,191,'65CCA5E079D38DCF32053D8DEE6C5ECF88E6AD8E1CF5379B','',31924,23,'',NULL), +(398,178,'FB895125A69DE5DB112B4731F6216668EB09C4F57943D85A','',706314,23,'',NULL), +(399,191,'A388E8CE523DB7C3C501AC5DB2C8AAE58FD1831E75665C48','',401992,14,'',NULL), +(400,178,'77C74B5E4CBCA9150FB64261E497AC4E7642A316C89B291A','',3045356,22,'',NULL), +(401,178,'8A2C4F7F3367A4648744D8964BB9A6833182ECABFE015B00','',3022016,31,'',NULL), +(402,243,'','',4609675,5,'5E5DC20800','Loggin Result'), +(403,191,'E8A24A78E6A716734CC666B48263B424804A42155C0BDB51','',18700,32,'',NULL), +(404,191,'3C881D2F0634D9223A36DF5266A7CF36B503DCF424441FA5','',28928,17,'',NULL), +(405,191,'7B3D92577810CAB5DA0134FDDA91CE6F36003C5373526774','',41023,24,'',NULL), +(406,178,'7F794E0811DA99DABA76CD9925B3E78045425E32880F05D3','',672746,23,'',NULL), +(407,178,'08235E08E4F83DDEA588D9FE32BD084FB26BDA6DEBB1E416','',668874,23,'',NULL), +(408,191,'5EF7C22867612F48FE5B41E219A1CA389AE8D32D8F0FC46B','',21660,15,'',NULL), +(409,178,'C7C78789911D6B30FA6E67198EF03B73CEE37576AEBFF5EA','',3045356,22,'',NULL), +(410,178,'62BF4E6440FE3F28138094B46FB469CDEB35008DEB652B8B','',3045776,31,'',NULL), +(411,191,'E24027620A1723C203E8084AD6269A852CD50D6F79D50530','',36544,55,'',NULL), +(412,113,'49CA50FCF2699AE5F4A867156A5D8053C4239B36DACE170C','HideEx',0,0,'',NULL), +(413,191,'073F4A76F248FE7C38F799437D475B9A2E9E81FA08B0C6BB','',17666,11,'',NULL), +(414,178,'6ECA7966F2845B9B61C6D9356E4FE4C913FE917808C8AFFE','',684876,29,'',NULL), +(415,178,'30BA488B3964465B142E75F6D1E1BA42DC9F489C3AC70BDA','',2299092,33,'',NULL), +(416,178,'55492051D368975D444428D6218A7D731555ABF7C3391E7D','',3049888,31,'',NULL), +(417,191,'94E0CEC4F7BDE7844C4D4ACF62E5C96ECF1D11FC2169CF8E','',433168,48,'',NULL), +(418,191,'5003A599A1162170A30F1906C0AD5B16DC7041E72D28A4B4','',28956,17,'',NULL), +(419,178,'686F700B2223502053CAFDF9977D8774E905E76B8C960E7C','',3049492,22,'',NULL), +(420,191,'F5A776E794B34ABBF93CA93E9230B7224CA088AB741DCB57','',13291422,37,'',NULL), +(421,191,'4A67D56DDA6B0E7D9117CFDB17EC6572E68B9300609FFE3C','',28956,17,'',NULL), +(422,178,'1B695DF78AA0708221E0EC2F5A69AB7078ED8143B2EAD174','',668874,23,'',NULL), +(423,191,'7C8CD40E29AE999923CD8EAFC233E619C73885A0258A6E3D','',21826,11,'',NULL), +(424,191,'73407824E9064DF5F1161A204A272A9CD69026EB4DF1004A','',29916,16,'',NULL), +(425,191,'B21609972E46C9BC8C6A77A18161A77D0C1D4001DC892DF1','',41080,24,'',NULL), +(426,191,'BB66A6AC45D02568067987834ECD8BF0A2BD0DAD06D12753','',17762,11,'',NULL), +(427,191,'2550EB7C358B7FB86FAF0EACDDC3111118769F448D93BF7A','',49347,24,'',NULL), +(428,178,'B6E4EF9350CA859576DB74D02C115D5A19C79AA58B0F6681','',684876,29,'',NULL), +(429,191,'451D2C8FF751743B52109FF5D95ED633DDBD8BCDB80EB7A9','',17906,11,'',NULL), +(430,191,'4A0161A4E5D50F11F58E1B23B281ABDA106625E3DC5A179C','',685304,44,'',NULL), +(431,178,'E4F21910D4B5D3E7B5461ED384889F6D0969645AE83F7601','',3037164,22,'',NULL), +(432,113,'B9756E3E1093B54511AC5A7B85711E53CEBEA373EF4866EE','Afde32uu',0,0,'',NULL), +(433,178,'A5AD6C8506004101E42165CD95051A7B5F13FBADD027461B','',710730,23,'',NULL), +(434,178,'B8AE30A02C59219D144EE95228C6CC9F99916F6FE423C940','',700714,23,'',NULL), +(435,178,'DAFD84BA8F977F5CFEEC9310C0EEF8F949F8EB6B827EBE71','',3990720,23,'',NULL), +(436,191,'B42986974893A82D73CC497B3252E9B844A11A99ACF46BEA','',41188,24,'',NULL), +(437,243,'','',11287980,8,'04000000903C9F00','Parental Controls related'), +(438,191,'0DC0953AE42E913121092DF17BC2BEE8BE133D1C53C8BFFD','',17762,11,'',NULL), +(439,178,'72C81E9BA425C54DE57BF4B7745D9C8D6B44D56E8FE933BA','',3049888,31,'',NULL), +(440,191,'100426CD22E80090502AA7A087B094B49ACFF4E7A09773ED','',30044,16,'',NULL), +(441,178,'46C797D1E60CC458E6C9D874650B996D10FC52641C2E7AA7','',676970,23,'',NULL), +(442,178,'DEA2C8A5775AA8CA86B8241BD418979D10DF4587E8E95C87','',250,11,'',NULL), +(443,113,'8807783067F9FF2697A61DEE925760682EB894C6F0A798AE','Afd32uu',0,0,'',NULL), +(444,178,'F63823A1F60619FDE6B4D6F3915EFB03EC03DEBEC82AFB9E','',673210,23,'',NULL), +(445,191,'E4DFD66163F2A65ECDD2EE9CA8062D707CC51882336F6483','',130380,14,'',NULL), +(446,178,'88182C96807A6025E628C90CE436C9EC54EC5FEC858A12B2','',690106,23,'',NULL), +(447,178,'EC322863C90B861E66A0008554BB8702EA92E1406F6F1711','',3070052,22,'',NULL), +(448,178,'9C851C7C05E54E5514E7BE038ABC5C669A3F5747EC573333','',3022016,31,'',NULL), +(449,178,'46D70E5C13F6D16BDD01A7481D9AFA51B73202070CA5D712','',673210,23,'',NULL), +(450,178,'CBEBB5F6F4EFB1324D17AB6CB48C573B639A37EAFD6299B4','',683146,23,'',NULL), +(451,191,'684575AAC0D8BC30D5325D56D3D522380E85ABFF380FA80F','',17938,11,'',NULL), +(452,178,'952BC8983C2CAEB6239BB2774F176A7F87A9F2DC10261205','',3045356,22,'',NULL), +(453,191,'4EAE0459E341062DB99658136D494BD79511B883F00BCE6A','',57602,42,'',NULL), +(454,178,'67E6E0A4006561DC5A67026886D1FF37AD14C5AA1AEA3CAD','',149,5,'',NULL), +(455,191,'222FE6B0A70CE2CEE633597E018706B3F78C338D96F6D9DC','',38300,21,'',NULL), +(456,113,'79747D68A5D6CD203671EF43029F17591E42BBCDB60B8B93','IPSect',0,0,'',NULL), +(457,178,'77ECC7613D44E56210F7CCDD6046226B41C8F087E901C94D','',682394,23,'',NULL), +(458,191,'77A59932BC8D497D992A213256ABD52C4D5F4FFB8A06002E','',49564,24,'',NULL), +(459,113,'2D14DD3BC859535580D8D9DC3BE7D59865A4E3FD112598A5','drvsys_mon',0,0,'',NULL), +(460,178,'9B487CD5032D00424A24FF3185AC4C17246729ECCE431951','',3049872,31,'',NULL), +(461,191,'978D8D1F3E1EF11CEBC4B65B13F1C5CE6E9E220E71B255B9','',13033,36,'',NULL), +(462,191,'1F5AD2397EB3CA814C5D156C6777C040F5D73085F3751C35','',433168,48,'',NULL), +(463,178,'912807952F9397C8F2B718C9164424D720E4EFC681DA3099','',3045356,22,'',NULL), +(464,191,'095F1A232F56B3DDA3338B5DE2CA310E5CF0EC0B6F72E87F','',17890,11,'',NULL), +(465,178,'2A5E27A3EE36254F61795E168A98C055772F88CEA5CCD6F1','',3033068,22,'',NULL), +(466,178,'4319BA4F2139568E87BAAC5F7C95121DD98D710B1C901E2B','',718842,23,'',NULL), +(467,191,'74E55BA8CDEFB5BD54BF1C0B0D326721D756440BA33C3ECE','',27270,13,'',NULL), +(468,191,'ED9FED6EE63B6C5E35C9E4615AC444603F6BF1FBC669D8B5','',13033,36,'',NULL), +(469,191,'DF967A96C67C8D6CB1955D1CA06556F37EEFC88D26F1D684','',90202,13,'',NULL), +(470,191,'2BDB1F4509561B2F846AAE7A5354008215C1EF4BDD0EA1D1','',49347,24,'',NULL), +(471,178,'0F3B3F0934C1B1E32DC9F83F67308BF9CFCCEB0EFE10B2FA','',672602,23,'',NULL), +(472,178,'E89980FFE6987D22DF5379283F53DA8DC3B5CD4862BA22C4','',335122,23,'',NULL), +(473,191,'156B3F2929664A16C3DA2D47CE3050B3A1BC32F9C30E4776','',27270,13,'',NULL), +(474,191,'65B03F581DEAA68B6A07C679C6B620A2623FD83EB4C4978B','',28940,17,'',NULL), +(475,178,'044C63CB9F480E28E02D68426C1F3D69BD146B39A7F081B5','',0,9,'',NULL), +(476,178,'B3BC7201BF77B362B943C8C13F9E70A751906F304F9AE133','',673210,23,'',NULL), +(477,191,'4783BF04A6BD423D63CD955407780BE0E15A70BC2643F853','',28928,17,'',NULL), +(478,178,'A71B471FFB4C58A2C99FC6818DD0269C4AE4C5686D5FDA87','',690106,23,'',NULL), +(479,191,'3EA0347F1F7D9BC9CAE387816DFBE4F492F53533400315B4','',17762,11,'',NULL), +(480,178,'AA5ADEE929B0B2FB655080B35D19607695F611672E6AD364','',3045616,31,'',NULL), +(481,191,'2DAAB5C524CA576967A7B0B713C1C34DA8EBF3990A86730C','',28704,16,'',NULL), +(482,191,'D0042CAE82A7121F7783A1382F542074B34ABFDF50A1B13A','',22792,25,'',NULL), +(483,191,'4D30286AD524AB2EB05C1A361A81036F787B1C0ACA36DD74','',30012,16,'',NULL), +(484,191,'03F9E0F9328E7C7025C0D5C59585700F19E29E8C8F9BF5B4','',49564,24,'',NULL), +(485,191,'430C4F44FD7CDF1A51F7A8FA5852ECCDA6CFA92C2A6ACB3A','',28920,23,'',NULL), +(486,178,'A2886E2080C54F25867AEDACDADD8F5175545F44512A3B58','',672746,23,'',NULL), +(487,178,'8438939BFCD0C550664ADE2DD75DD15FA23DC435EB5FC011','',3638348,23,'',NULL), +(488,191,'66480AAA84C5C00B64EEABE96DD21EB3773228B144E25D0E','',20512,16,'',NULL), +(489,191,'76C1B0FAC29E4E41FC6DAC31A0592CB0087BCE0D052904FE','',61874,42,'',NULL), +(490,191,'DA219765DA22ABBDBE5486CF7DB01C283FBF9986732C9A91','',37180,24,'',NULL), +(491,178,'F58BFE40291DD85F45C47E0E255594382DE0180AAE1F1FC9','',149,5,'',NULL), +(492,178,'8D8A305C43A3DD47DE550F256BD5F4B1753EDCC079AF279E','',3070052,22,'',NULL), +(493,191,'69CA60928A9A85D79ED39596C018DF899BD14C6219EFE088','',41080,24,'',NULL), +(494,191,'8D9AA947B904C003D06ACDF4EA0C84104612B274696999C4','',17890,11,'',NULL), +(495,178,'289CBF469FC750449980BFC2CA6AD7E42A69E14595D140A3','',209352,75,'',NULL), +(496,178,'49961CDE71B612E5432EAB389E7AD193476E05BB2778B751','',700714,23,'',NULL), +(497,178,'43818F9575A04BF426F4BE167052859015CC63622F7D4F3A','',672746,23,'',NULL), +(498,191,'7828B55FDE24719EC377E29FAE55BA6324020D00CD42A99D','',360508,13,'',NULL), +(499,178,'5432916108AFDFA313B6D88C886D87B5722E43EEBCAFC627','',0,8,'',NULL), +(500,191,'106F24060B7A4FC87A7971A4B0EFC1021F7181A09598C336','',17906,11,'',NULL), +(501,191,'13AA99805639421566A2652F0A7104939EA52EF0F77CFB03','',24812,14,'',NULL), +(502,178,'D0938B578EC70162A30A25571CD5DC7E765780F6191EAE1B','',710730,23,'',NULL), +(503,178,'70FA2C3749960F1B0D881FDB186DB9992D6EFD30C6674104','',580768,52,'',NULL), +(504,191,'BCA2CC6F5740DEF5D01D314146879036A5B6965C01424B0C','',45223,24,'',NULL), +(505,178,'47DD279576A64BCB3A4AF23D55895600C73BB5C214B70AEF','',3049452,22,'',NULL), +(506,178,'09C9B53C215456866BF764553A7B7E4F1F20F33A8D2CB613','',3638348,23,'',NULL), +(507,178,'3EC2D3876D82F424718D3B8E0B87562244C3F5A11A29F0E8','',682394,23,'',NULL), +(508,191,'7B4E9BBDC89694CCAE5BA6996D4240EB2E0C9C7F03CC5D40','',59620,13,'',NULL), +(509,178,'E2333772B05ABC620076EB66CFBB4AFE2313CCB6D719399F','',3065956,22,'',NULL), +(510,178,'2EB4C04C0946264F5BC8EFBAA832CA97381A8A6523BAB093','',178504,96,'',NULL), +(511,178,'0E3DE8374276C08D5DD241ABA2AC0AC1D2319F5CD22AAB52','',2303444,33,'',NULL), +(512,178,'FDB8DF478DADD2E36619D63D04D106EDB86EBF8FB9EC8CB4','',3000288,31,'',NULL), +(513,191,'BA76761FA5F569497047C3484FBC6FDDD8AFA71B96FE93C8','',24812,14,'',NULL), +(514,191,'2496E15413F7008A01FA53AC109C01E45B80BF2C3BC2F205','',56063,25,'',NULL), +(515,191,'CACB6383E8613E41489D93D7FE7235BE61214F9AE0825F44','',13291422,37,'',NULL), +(516,178,'931C403D2562AEE58EEB2586D73D51323A3A739860290AA6','',690106,23,'',NULL), +(517,191,'1A95AFB270B9C0D170E7280816891492C21E87D92E9EA6E5','',433168,48,'',NULL), +(518,191,'7483929857AE7A16C2D9EB0857EB1D5E9477479C2EEF0B5C','',37180,24,'',NULL), +(519,113,'379E1F6905F203E1026DB54A58AF588EF5726D9F50FCF369','Afde32uu',0,0,'',NULL), +(520,113,'08394625CCD77F36897EF283FAA0C019EE9F36775182584F','Afd32uu',0,0,'',NULL), +(521,191,'D9ADFC0283E75A86A3E1672BF50F5D1AD8E8466AE7086437','',27270,13,'',NULL), +(522,178,'D37F6219417C0E5196D3A4473D57ED767E6D9B49BB2B9555','',0,9,'',NULL), +(523,191,'93AAFBD4B8B50D6AE72F3BA7002D76791942D0EC0E61253A','',41127,24,'',NULL), +(524,191,'F9B132A5E1FFF379EC7175C12A58683C85272CC96E03E161','',41023,24,'',NULL), +(525,178,'1867D3CEC9379D1E6B8A1B9B667BDB1B6084B02ED9A60864','',3037164,22,'',NULL), +(526,178,'86548378A25632100F7E6E872ECF4D591B7542D977B623AE','',3049452,22,'',NULL), +(527,191,'9E00F6F9AF1D63FA2628E60B7BF2B1D63EFDD42D69929A73','',41080,24,'',NULL), +(528,178,'7DDD4CF1352822A1F9D19775498EE865FABB26C69F8FDEFE','',209352,75,'',NULL), +(529,191,'3D793384AD147BDDE98743EBE1E943263EFD6CAD542E2757','',17522,15,'',NULL), +(530,191,'9014AFDE93FDAC6C20971BEE76898FBB300A744CCBC24DA1','',28956,12,'',NULL), +(531,178,'D1212D7155D2C3114DA596070139C0B3610597CA0CE1CB17','',149,5,'',NULL), +(532,178,'BE18517661568A9D7F3CC9548592867F3A987A705866F60F','',3049888,31,'',NULL), +(533,191,'5D833D8DF05A7AF50DF945F5AF6880D325AC52B3ABC815AF','',41188,24,'',NULL), +(534,178,'1AA3B0D9AD368562F181E4E5D498652B3859210C126824D8','',672602,23,'',NULL), +(535,191,'331E027A700CAFDBEAC9E80B68B8304D0895D52947447448','',501956,48,'',NULL), +(536,191,'8E704337CE9F823A8A93947130ED1EE14A99F2EDB5458B94','',12194860,37,'',NULL), +(537,178,'BB1C818F79DB2F1FF71B7CB181021EB4F425311D09DAAE81','',0,9,'',NULL), +(538,178,'F1AD484D3F189A08EBF420C235D16ECAF1B485092FB063D6','',3045776,31,'',NULL), +(539,191,'1CF7028BE4D68B7AC6BB8061BECBFF402860541D04C90C0C','',17906,11,'',NULL), +(540,191,'2550D8249054E57086D4F4CF80396C686A71673C070711DA','',17890,11,'',NULL), +(541,191,'E864BD00AEB4F3D18CFFA7AADEAC7926A9A1E3EA7588F17A','',29884,20,'',NULL), +(542,191,'9E70338B4C8C845F8514925463DB624FC4423F9C467F5E62','',685304,44,'',NULL), +(543,178,'FC5EF49EDEE7A5268395298071BBA270822547A7416AEFB1','',3634252,23,'',NULL), +(544,191,'8282F57B7C3CD9B449B6363D5C9E792C2044EA2C3F381F9F','',17282,15,'',NULL), +(545,191,'B793EEE20E44B2942C6522F79343C58738A1A8489A381FB0','',24812,14,'',NULL), +(546,191,'6178EE9E575927A3505835AC88DA31BE15F0622DA55B31EB','',28956,12,'',NULL), +(547,178,'7BFD2D88793D6AB1A2351A3E8873B1E20CF44BF6563A0930','',3049888,31,'',NULL), +(548,191,'4102F13984A4E146C134D3F607AE7CA1B3263A22B52308C6','',447736,48,'',NULL), +(549,178,'EA1C4CA2A64548757BC2ED1C5BB6D2B5094AAD5B5C331F7D','',683146,23,'',NULL), +(550,178,'BEB42A9DB2B656B2DFF3DD7D1B8D87033F1D99A019CD4BB5','',3045632,31,'',NULL), +(551,191,'4E209437251EBB0CF31CF8A7CCF2C873A4D759B9563D573E','',34176,25,'',NULL), +(552,191,'85EB9C8A36B32287F096CF73F7FAE8B57405321342E9B779','',17666,11,'',NULL), +(553,191,'2EDE42629DD4A72669FFC9BBFBE15F357BF241853DBF7B2E','',27270,13,'',NULL), +(554,191,'FF47A1D9514F4DD81BDA23FC9018F03D894F9096E26EF809','',18680,35,'',NULL), +(555,191,'65185BBCA1D9995EA4B796E908B9F78923FDAE2D0C2500BC','',594348,26,'',NULL), +(556,191,'BD55E51B55A8FAB82CBF45012D761B1BEEE9BC0DAD8A83CD','',28920,17,'',NULL), +(557,178,'AACC3E694ACD478B1F99714734B5A43BD7D7A2A3565ED9B2','',3049492,22,'',NULL), +(558,191,'F3C07663325C5358F58A547725FBDF8DEF591021CD94513D','',685304,44,'',NULL), +(559,191,'503B5AB938616DE7672103919957B421FA8B6C98F72375F6','',20512,16,'',NULL), +(560,191,'3B6EFA3FF9443BEF4CBD2E7CAE08DA1753C79E5EDFA8510F','',37136,40,'',NULL), +(561,191,'3E5D1B5BBAD191442388FBD5236F5406CB2CA68EDF986328','',17666,11,'',NULL), +(562,178,'D8AB51DCC7840369846821B2A6B229CBA2E42C0CA566792D','',0,9,'',NULL), +(563,178,'F8004FA24C4925FAA3ED4993B0D457C5E4C5371915BB93D0','',3037164,22,'',NULL), +(564,178,'EAF4A696D564F6BC800BF0F6D732E4E92B50133DE02EE8C4','',0,9,'',NULL), +(565,191,'30BDC2BC3E4A2055426FA0EC67DBDEB7705C58047EFFA4D6','',61874,42,'',NULL), +(566,191,'3C8BCED97B2F9E5A52587E725004E136DED2B53AB2DB9D4F','',20512,16,'',NULL), +(567,178,'0B586F15A8CFD6B7A96632FF2B48D0F71E9D06BFAC174002','',3049888,31,'',NULL), +(568,191,'B2B3043BF9CDF3DB535D52ABC45BE586E6B8097B58D82C45','',17890,11,'',NULL), +(569,191,'9ED22064CDACF86DAC8C365C325EE428A87B628D137E038E','',28920,17,'',NULL), +(570,178,'2254B046D6D8D1A47E5F9275474B5EEE7A96CD99E8D952E9','',682378,23,'',NULL), +(571,113,'0A268B6DB28320A1956B54C36C61C625B02A48A4768A0823','Afd32uu',0,0,'',NULL), +(572,191,'41B3450DB8D10C506A561C7B95354A7792286D837C08B437','',12194860,37,'',NULL), +(573,191,'5CEDF5982800D9C6D16F9D357AEA17BBBAABADC8F3A12EC6','',45223,24,'',NULL), +(574,178,'3399D1DE6156FDE8614333B6C4AB0F5B2354381AAB7AF818','',3049872,31,'',NULL), +(575,178,'31DA5322A7B1F1715CA35F0976C201122A76D46A719F0C28','',335122,23,'',NULL), +(576,178,'36172791F3ACC5EFD406A7AD6F5D218279B94D458BDD60C3','',700714,23,'',NULL), +(577,178,'C64DDA3E5D94BD0DEFEDDB867DD304177B554C5771CF4DEF','',682378,23,'',NULL), +(578,178,'701D57AFE1315795AFE1340C35E923FE69C36EFC670C0BA5','',0,9,'',NULL), +(579,191,'D55BBE3C196C2FE07829CC54717C0A2A27C13A38ED4CF582','',30012,16,'',NULL), +(580,178,'DAD3C22D23FAB30C9AA6796E19EAB23CB7DCCD639854C14F','',3045976,31,'',NULL), +(581,178,'B3EC9710B55079104420F126BA7257F8FD7DC39D46880E5B','',2299060,33,'',NULL), +(582,191,'7762CCDD012D51167BF42F775CC307238C35EA5DA55B999E','',41096,24,'',NULL), +(583,191,'CEB7B2C893B8410CA8716C77DB679AB860F7F0E86BCF2D8E','',12194860,37,'',NULL), +(584,113,'C584FF543FABE32DBA3206AB324CAFAD92497C4926BBF8B2','HideEx',0,0,'',NULL), +(585,178,'122B96C9AD3D43FA5EE82ADFA464904F304EB7FD4CB5622D','',2299108,33,'',NULL), +(586,178,'3EFBC5B273BFF42D9F704C74DC2381B8A0D50D61C2F1512E','',717898,23,'',NULL), +(587,178,'8C5824E4A6D16714A2BFB5FC9D0CBF4706B8A2170DA87D7B','',0,9,'',NULL), +(588,191,'402282B90E06579656CF454305C0B5A925C95FBF6A7CF265','',477928,60,'',NULL), +(589,191,'71B36C6D650EF0D049328643E5B12E73DF95B58B2F30D0DC','',17938,11,'',NULL), +(590,178,'7C49C303394E1493D897E802528CA8E558B6A7BFE8320F08','',3037164,22,'',NULL), +(591,178,'2C190F9E920AF2EF67DA4D06905C2A6A0A2BC63D0192BAC5','',3045632,31,'',NULL), +(592,191,'E59168C40E1A0C9F8896EA9E2D684988D81A522FFCDC51D5','',3766400,37,'',NULL), +(593,191,'3C825803D3ABF20A11495E54718A2D83A0B35FD7D741B5E1','',12905,36,'',NULL), +(594,191,'DCF32E3E1C5DF813DFB137A2D9B21D95B0AF66CC2AD0F245','',41023,24,'',NULL), +(595,178,'7B66BDB4A0A713A7B315888708B88F90CCF7313832CCE35E','',3045356,22,'',NULL), +(596,178,'FFAF20DD14D7018A4156F000D1455DF36966513EB76F93E7','',2299116,33,'',NULL), +(597,178,'0C59AA1F05D2D9D3C0C5ECF6A38D9FF57187A7A461DEE908','',717898,23,'',NULL), +(598,191,'913AA6D16EBE73143FA4B4EF89C786668C6E7DD0B936DD18','',90202,13,'',NULL), +(599,191,'A9F5CA81A547D8F8051928A287DD280F7FE835B2858CEED5','',20512,16,'',NULL), +(600,178,'16B4D8897AEED4732A47239CDC99603D2F505D0AD602847F','',673210,23,'',NULL), +(601,191,'23F29E10D55E8701A1A699A1C05CED4553676E9FBA5B51F5','',13634,11,'',NULL), +(602,178,'9A65A024256C0D7D677C9F24A9C16A48BEA9B03CCA016098','',3000288,31,'',NULL), +(603,191,'AA0004288ED58DE4324FA521F849807DB1EF33634C7FE8C3','',61874,42,'',NULL), +(604,191,'E400A401BD0376A0475F1216731F5EE0DDF42C9A4FA805D2','',59620,13,'',NULL), +(605,178,'FD434987A57E848192562B61CA0D67BDCEA2392514CDD0AF','',3000288,31,'',NULL), +(606,191,'88C140A6580061C775D9141887FABD3F20E574DC4C0C4BBB','',9977,32,'',NULL), +(607,178,'3623B441A5D414AFD6650C8B8623ECF3C3A9129E1F5A81C1','',672954,23,'',NULL), +(608,178,'393A06D430D287FEC1C02F9945C34BA2A7954241C6357909','',335122,23,'',NULL), +(609,191,'0955A3267A3E576B9BD823BB210E8200F37CCB0421BF208C','',685656,44,'',NULL), +(610,191,'1A00ED18B456ADC1A1F39A5DEF572250FB0CCAC8BECA9DD8','',477928,60,'',NULL), +(611,178,'370B9B6E3AA987595F986C5716BF9FFCF0369438D5DC5D11','',156,8,'',NULL), +(612,191,'E8E85DFE24D8D20852A37D702CDF029C3B1FA30B99CAA4BE','',447736,48,'',NULL), +(613,178,'FA24C5FEEAF4538DD4913F10C99F3F64380B7354EB318386','',3041472,31,'',NULL), +(614,191,'C6AD92AC13B340575AB5D0769A1A7EED47BC42A5968E67D6','',37136,40,'',NULL), +(615,191,'990EFFE367D44A29E82F62C57B6041A66F66C1D100B05639','',28956,12,'',NULL), +(616,191,'631E42C3B6ED8A22F5AFA903176A7EB011754F5ABF2081EF','',3766400,37,'',NULL), +(617,191,'D8AB4091C51177D7BBA7384EE12E0384A7EDB73E38D15920','',13291422,37,'',NULL), +(618,178,'54AAA1926869D259C427870A620AE0C24AFC9B472F424633','',3049888,31,'',NULL), +(619,191,'CC0E40919988E53DA0B447F0984A30D51CC42E9DB54A8F1F','',49564,24,'',NULL), +(620,191,'396E7EC540DC2C74CD6709753CC627517E3A2DB8A1EF3633','',29916,16,'',NULL), +(621,191,'84A5A077180DFB9841E8DF4A4EC49EADE886D905768EE032','',57602,42,'',NULL), +(622,178,'072300C283F8DF72B3ED5F3CD8B7DF47574AECF7B21FBB59','',668874,23,'',NULL), +(623,191,'D4FC9A6022B7CFA81904503E43B813631D4735D80BC61868','',9977,32,'',NULL), +(624,178,'47B5A19B87234257CB6C1485AB2C0CB25513260F60094BEE','',3037164,22,'',NULL), +(625,191,'B8B6F4BA5FD45F0ABDCB060F72987987B6EF62B80C9E378F','',12194860,37,'',NULL), +(626,178,'261F2915266F20B7289A1560176F24198930C61540BEFA01','',3638348,23,'',NULL), +(627,191,'019A378006B0677C0B2F42C6CA882EC571D504E7D8F5B05B','',17282,15,'',NULL), +(628,178,'4E82DD9F04571D6DAB2FFCFCD638699D1D4C84917F720F32','',717898,23,'',NULL), +(629,178,'EAA75F6AE049552C55AFFDABB7268682428B1A9BF028C4D4','',673194,23,'',NULL), +(630,178,'F1431C669453FE0BD95430ECD8328EA0D3CD37BA658F094E','',198,12,'',NULL), +(631,178,'8AD8C581E8BAF7A2140211C4298A93E229493F272F4EFF4A','',3045912,31,'',NULL), +(632,191,'C154E3B6CE0B979BA98FEDAA1829DCCF2A7172642DEF9EFC','',37180,24,'',NULL), +(633,191,'295A29C81B1B9CC9B6758440BED913ED4D8B5E05A90D7CE7','',41023,24,'',NULL), +(634,178,'3ED9105E3D1F31AD1D4376C54B07D18348C56E7453D161B2','',690106,23,'',NULL), +(635,178,'74C75B8F0147ADA8610F6C9BB80C4BDA543C1D95943ADCEB','',0,8,'',NULL), +(636,191,'7BE7A7D3F4AD8B30A0A144D5D4AC5E569BB9A0D18AB590FC','',37180,24,'',NULL), +(637,191,'0B5C54A4850924038D95A3F1C44F300921CEA1E13644842E','',57602,42,'',NULL), +(638,191,'876743AA30D61C83444427F4F18203B2FF443C337E5DD190','',22792,25,'',NULL), +(639,191,'C83A14C21D1E66345574E3E0E3613E924F702883A30A1809','',31924,23,'',NULL), +(640,191,'2545F02B4FC2F5425960A2E5C0299936C99FF2EC68A5ECDB','',501956,48,'',NULL), +(641,191,'85EF9C6353712A8D0E2E27B1702B510A95B1305473F86345','',41023,24,'',NULL), +(642,191,'35282392AA86692A153FC159D6E13C74F9DF01661E4867D6','',13538,11,'',NULL), +(643,191,'0D6CC3008615CD5BFB96A90620805B78D5BFBC6100B1AF0D','',13538,15,'',NULL), +(644,191,'D573179188521C485CFD24A9EE9CDA77C540A31EE68E3E78','',41228,24,'',NULL), +(645,191,'8FA80694C3766FC1B041103EB35EBA3B7C77081A5DA8FFD8','',28940,17,'',NULL), +(646,113,'CD6B8F9D23612C807F7653D29F1F1C54BC8F917C5C5BD8F1','Afd32uu',0,0,'',NULL), +(647,178,'FCB5CF830DB536208D4C58E5838D1C8798F0738247EF0867','',672602,23,'',NULL), +(648,178,'4451680A3F41926C1545701887F93A0A49CC29C3E114AADB','',4011280,23,'',NULL), +(649,191,'6BE2C4F29ADF49AE5BF0485A27A854087E775FA28047168C','',27270,13,'',NULL), +(650,191,'016FF5D8685E37969B1B7C310756DCD93D4AB34256837031','',38300,21,'',NULL), +(651,191,'6726DA4A8F112CC25DD78500CA9BF792DB688F7D8D1FBC4B','',57602,42,'',NULL), +(652,191,'9F8B3A3C70027496420A619969CF1EB7AF447D245DA766A0','',29884,20,'',NULL), +(653,178,'E74FFC8ADF5FE8A0FE0F10BCABCFCEDB3B2B9C2307340D7C','',3041472,31,'',NULL), +(654,178,'B31302D6A47971059B2643B57D2D50EBEBEAA89BE483F1F4','',3037164,22,'',NULL), +(655,191,'2F761DEA3CD3394A0091D745FD2976B52F3B16BB0A48BC80','',29884,20,'',NULL), +(656,178,'8E44EC966A93870696359D3E2474D12C071A381B9403B1B9','',673210,23,'',NULL), +(657,191,'2424AFA7FEC48FF09E5E3BDAF93FAA74743A7551B6FB1495','',56063,25,'',NULL), +(658,178,'ACCF5804D419F30643F87A650C4DC6E0E10266922692AECE','',682378,23,'',NULL), +(659,191,'6EC19D6D1244E3FE787AE448EC905C509DBA3C01FBE34F24','',41280,16,'',NULL), +(660,178,'5B2D2EE40383C33D381998995210918AC6B1AD67C5880F6D','',710554,23,'',NULL), +(661,178,'83FFE0F8F224D5E56C38D731EFE8AD5AD1285B1AD4FA019B','',683146,23,'',NULL), +(662,191,'9D67A809FD8FDA1E1504F0C038E21E1D5FC4C6D11F426228','',28940,17,'',NULL), +(663,191,'2965EC092EC0A4B3D4A3C781F0A0A542824C77B7300BF50C','',45324,24,'',NULL), +(664,191,'FE31901F5558E6555DA6BC5B1BC3415E82CB97DECBB486BB','',41096,24,'',NULL), +(665,191,'B35406A77D6501A50F41981C7C137AD5272EB612F4A74109','',29884,20,'',NULL), +(666,178,'7275397E511B45264BCFA30E3A3F8101894AA3923D91BE6E','',3037164,22,'',NULL), +(667,178,'CA7D8D0E1F20385DCF6FC209799750CE9D0160B0C67196E7','',700714,23,'',NULL), +(668,191,'F5CCDA244D826B3180E7C49193B3B0B5DBF651EC67DCB47A','',594348,26,'',NULL), +(669,191,'7977F1E72B30179072EE1784396AB0406D06162051CA1EDB','',37136,40,'',NULL), +(670,178,'603F8A015D8436CCBCD68B26FF6006E7A81BA9A8D9524B1F','',3045356,22,'',NULL), +(671,178,'9631E9EBC78E0333010E522045852C7BEA44655080D418F3','',3049888,31,'',NULL), +(672,191,'43BE7C00605D9FECAEFAE38D8FFEAED78B8382563A245F10','',9977,32,'',NULL), +(673,191,'E493F1BAED1DBE7A0D429BF1A5D665636D29069060310BF0','',13291422,37,'',NULL), +(674,191,'6C53203FA95EBE4DBB0A7F3E85994058DECA069A5244C29E','',130380,14,'',NULL), +(675,178,'5A07E5A0525DBD5005CBDE16F7393EC8B795ADB2327C2F96','',3045356,22,'',NULL), +(676,178,'D7665366F333BD580C5F8E2FF8971294F69E99EC7E3623F3','',717898,23,'',NULL), +(677,191,'FB87EB8F178C69D9F7576AC7FF75D0479467057A2B6C956D','',9977,32,'',NULL), +(678,178,'292911AC98E7ED34DF021B562D5DEBE8DAA15570B552978B','',3000288,31,'',NULL), +(679,178,'6618F45C49D47C4105070C085FD5C384254A62E4AB614DB9','',3634252,23,'',NULL), +(680,191,'316E531545999AFC533814888434999501FEA8ABFBAF8655','',134968,32,'',NULL), +(681,191,'9945ED64886F68664A4BDF50731F4B4DC680273AB2E0DBCB','',20512,16,'',NULL), +(682,191,'1D4D6EC7B6B26553FC914D28BF9B62FD81D0B865DE606D97','',29884,20,'',NULL), +(683,178,'63B2D2ACF6E912CDC68282B080A2D610BE6AFE8EBB95FD31','',3070052,22,'',NULL), +(684,191,'B0955BAC042D5441496103E7C45E38609A9AE3799D534BD9','',18680,35,'',NULL), +(685,178,'6488E44D4E965581650F73F6E68DD8F863795162D99104F8','',682378,23,'',NULL), +(686,191,'CC0D3F7D8FCF928A55F92F6414F4AEF7AD75DED5819BF870','',13538,15,'',NULL), +(687,191,'CD3835965AF27EC338F828666CD06089B847B04A2DD56AE0','',17938,11,'',NULL), +(688,178,'D04E9CF6A03D4767AFF1E4EE0EFBC333AEBA5B0552F15957','',0,9,'',NULL), +(689,178,'120904F033D78A13DB0971F095C809852B7EB876D1A8AA01','',3045632,31,'',NULL), +(690,191,'7DDD19DCF77E27DF0A31BC21C7F716FF85076AF065F102DC','',36924,24,'',NULL), +(691,178,'5486E2CDD98AC3F25C223FD515CE7EF3FB09AC12ED338C86','',198,10,'',NULL), +(692,178,'F8D6423F01E5369D16F6F70180083B936F0DDE3737B23308','',2299092,33,'',NULL), +(693,191,'EC10CC349A8E654240B27B03EE1232B9CCED28F7104CCB71','',49347,24,'',NULL), +(694,178,'29E064ACC509206873A1D548F4816DB60D29D6EE9FF63A56','',682378,23,'',NULL), +(695,178,'E1A8A2A81920A7BA9F419A6D19CAC3DD9E292EF39F963234','',676970,23,'',NULL), +(696,191,'32393EB09F7C829F58612E5E47018F7203C43218C3506C79','',20512,16,'',NULL), +(697,178,'AFC4D19CACEDE8E9A2FDE3CC3D29CF8556AF4980872DFE1A','',3033068,22,'',NULL), +(698,178,'09A2B97FD351B1D339030233AC51C741E0ECDC21AA7A152B','',3049452,22,'',NULL), +(699,191,'2B2AF2171B8A9FC0D44EFE0ECDCB9DE1A55ACC8D83661E16','',41023,24,'',NULL), +(700,178,'D111B236DC42EB338870E72FF6EE3141714D0437864B02AE','',3045356,22,'',NULL), +(701,178,'E6DC6898929D1DA9F5768A9BFCBE848F8C1F31E8B6910FB8','',335122,23,'',NULL), +(702,113,'85A32F8B5F8430A086D27E62EB17D878E49CE815F6AC91CA','IPSect',0,0,'',NULL), +(703,191,'B6CB7B905A6BDD64BC032BE71927C1FE31153D14D6CF87E1','',447736,48,'',NULL), +(704,178,'40EE7F4EEE1D707ECB770CDBBB54730CB863CC8E268D4208','',3634252,23,'',NULL), +(705,178,'D74E308262D8C52ACE81B66F1D90C160AC86B2E0508176C1','',0,8,'',NULL), +(706,178,'E15287D29EE155299619F8E93E66B55B564FD921FA41CF50','',3049452,22,'',NULL), +(707,191,'58DFAEE44A52F0D5A58B0C94F0E5E63C1C7F76206D7FA7CA','',22792,25,'',NULL), +(708,191,'83705EAE8AAD9709494E52EB05AC0481C998C15730E61099','',30012,16,'',NULL), +(709,178,'0271F4D624304A48CB7CDFA016E3A735DCA3170FAD557468','',3070052,22,'',NULL), +(710,178,'217DFFE3C12F984992E1E0AE7B5864061572BA301B21D869','',178504,96,'',NULL), +(711,178,'C5C7AC33D1E4CF33E661033006BFEDE08523B643CCF51261','',3045356,22,'',NULL), +(712,243,'','',4618113,10,'FF1554F79D003B470C89','WS2_32.Send'), +(713,191,'D45144FC835266270E67CFB1F2900FD227B63204698A3EA7','',50040,26,'',NULL), +(714,191,'B5BB832AEEC591196864E08A392592C5789D76D3DDDD4DBF','',27270,13,'',NULL), +(715,191,'93582814E00150E2DD750ACAD7BD1719C4EBCD4C06F482AB','',28940,17,'',NULL), +(716,191,'FD6B6AC7FA5F2E7828CB1B429A9442383BD93E762A5D7D00','',31924,23,'',NULL), +(717,191,'51DF4EDECBBE42CC7C5D6723318F98E43E14A45F41CBD124','',41080,24,'',NULL), +(718,191,'F2B2260FDD23E5F268FAAE4D1A48E74C452F2AC5D114765D','',57602,42,'',NULL), +(719,191,'69FBDB69EC2E113EF691E47EDD46E40F03D1EBE226A1F7CE','',29884,20,'',NULL), +(720,178,'E3E431D8F8FB38F0F2586D0F50D809BCCEB13651C5EF2619','',682394,23,'',NULL), +(721,178,'2294015927F07D884FE2923FA17B3A8BCABC0A378930CF84','',679578,23,'',NULL), +(722,191,'0A022AB25C52F94404A01F96687B2D6E6BE774237254BD05','',20512,16,'',NULL), +(723,191,'65EEE243504EDC3319C3528B1A1E8061A3E75F4C25B61F95','',41228,24,'',NULL), +(724,178,'877C654036A29FC108FE8D69D416361732D7A0270E51189D','',3022016,31,'',NULL), +(725,178,'1A223564DF9E7BADD3CF858FB8250FE59F892232AC3B412D','',4011280,23,'',NULL), +(726,191,'4FEDF58FB4DE45289C97ACCF16EB2DEA6FBC85C74A52D3C9','',37180,24,'',NULL), +(727,191,'D4BE47EA1D68B92E2AD8307D139877705BE2B6A98B6A916E','',13033,36,'',NULL), +(728,191,'9658AC7EF426A52C327BBC1ED71C6FA6DC5940E35DCC18C7','',18680,35,'',NULL), +(729,113,'1B17998CD8E0CDA4D84B0A0F9DB05E536DACE0348A883D24','ndis_x86',0,0,'',NULL), +(730,178,'BB9B86ED12359A465B02387A1D727F11F78D35C8B7FCC2FC','',2299092,33,'',NULL), +(731,191,'842BC1A8C53902D26018B1C5E05ADCD70D973A968E298331','',50040,26,'',NULL), +(732,178,'3E894F9682573CC0AD54C7E9873C9026AC050929392D0B93','',3049452,22,'',NULL), +(733,191,'4A31E3D24FD6D576D84EF1BFB813D0F066870DEB38C32E47','',21826,11,'',NULL), +(734,191,'EEA122B4C066EC0B196F67511E633EBACB37C4EA6AE4BFF7','',41096,24,'',NULL), +(735,191,'66211671BEF80FB973B1C9595A70B462AD79EC83530DFE89','',12905,36,'',NULL), +(736,178,'3760BBD6FE99A0BBEE0AB61A8BD52A6ABCAC48FF3CB265B8','',3070052,22,'',NULL), +(737,191,'70F425426612D0D8495386C2375F7A4183548C0D4E7DFA46','',594348,26,'',NULL), +(738,178,'BB310E9DDE9259027123500E65F9FA1E8D9D0F5FE8381CD2','',3638348,23,'',NULL), +(739,191,'6FFB5E4982D306680E0C59087DA961CD4F6B068E323C3BB4','',401992,14,'',NULL), +(740,191,'6DDCA79B7460A1F3671532A28FDCEB331DE6CA550E3178D0','',3766400,37,'',NULL), +(741,191,'A8F7B2FB37CF3BEF43D6CE5C0BF85E85077E681490BA1C4C','',37136,40,'',NULL), +(742,191,'052F425E7528B3A7155C45EEE530F915DBB154E5C8876E25','',50040,26,'',NULL), +(743,178,'D6DE200B631AF71BFBC76202D82649942FD6ED9BC4A9EF75','',198,12,'',NULL), +(744,178,'61077261C66B2CF9B199F115A3A656EA6A00068F151E3656','',706314,23,'',NULL), +(745,191,'513FC0F0673A9DF86FA1FA05371040C14634CE08311ED619','',401992,14,'',NULL), +(746,191,'5E0970A6EB246A79DDF427CB76D0D921F971E13921DD5D2C','',134968,32,'',NULL), +(747,178,'53CAC3EF654610AC7E043C6AAD62709EF0B5400DBDE755EB','',149,5,'',NULL), +(748,178,'566637D06BAEA9190B7CE510C697F72CD20FE3D958A95A25','',3049888,31,'',NULL), +(749,113,'3C9B0CC7FE020EEBD43E6B1D88EDDF0EC46AC35974765068','drvsys_mon',0,0,'',NULL), +(750,191,'BDFEE5DCDD37FC5B2A1B3E42FBE5F7997CFED35E86062EB6','',28920,23,'',NULL), +(751,191,'7794AE60131E4D07860DB48047206784B885B30457EAB83E','',12194860,37,'',NULL), +(752,178,'653A308BB00D914AE1ECD773BA4B0BA7724874BC62647D10','',3037164,22,'',NULL), +(753,178,'06B696C35F905E75B451A02E121BDA0330CD44E0D9B872BF','',60648,56,'',NULL), +(754,191,'35E8CD9E8CBD879B1E53278926C634AA8B72B8D9A20009F9','',17522,15,'',NULL), +(755,191,'9B13F2E744904ADAAA062F9113A576D11C2C450D1CD6A4AB','',13033,36,'',NULL), +(756,191,'60851B4A6F7338632A84795FBBB20320E49AD2CC2034BA80','',28940,17,'',NULL), +(757,191,'3BC0BE02AE0B6975974D3B13B811EC6BDACBF9EE122BE633','',90202,13,'',NULL), +(758,191,'E47F7DD8D5B5C29B70AFFD4F25AA286167D411937F9BD247','',36907,24,'',NULL), +(759,178,'35D1CDEE86A410DF087DE6D5F5AC6289C4888B9753293E73','',3037164,22,'',NULL), +(760,191,'2ED2EEB29EE0D48477779E5CA875F1F5F15CCE74CA85BDAA','',28956,17,'',NULL), +(761,191,'A373FDB6A789CC46072A4CC51A429C817C40862DC6C0190F','',30012,16,'',NULL), +(762,178,'3D02551F548DFB58832626FE90A7AAA12824D93A54A0DC14','',709322,22,'',NULL), +(763,191,'09D04CF8ABC51D06D874784442987E5F2631041550607255','',36544,55,'',NULL), +(764,191,'F3CD473F8C85977895CA5BA9DC22185BCCBBF6B977205193','',448492,48,'',NULL), +(765,191,'30E2F23DB1038D16D2DEEAB1D0F1790D961E468368DC5108','',30012,16,'',NULL), +(766,191,'540D465F760320A63981289D30CD40CCC770EE126523C71D','',477912,60,'',NULL), +(767,191,'C461E1BE054FE29A1FD58B33D33890BC4A1279DE4F572B47','',37180,24,'',NULL), +(768,191,'1AC3D903CFCA11321E76A257BDA0608E5060030BE745CCF3','',130380,14,'',NULL), +(769,178,'96281A2887E61232007D7015E4A35DA118794841A8EC84BC','',3037164,22,'',NULL), +(770,178,'8A1AC926B46A9E3D60D3BD87A59FF77D7B80A1510BC327A7','',710730,23,'',NULL), +(771,191,'3620B6BDF3993B87FD35E906FE8376A04FF34684E2023D8E','',41280,16,'',NULL), +(772,191,'025C373F05EC6E809EF5A86A903570FDA14D219286BCED5E','',448492,48,'',NULL), +(773,178,'5C0E4EE98C4E34CBE44F6BD595C13DD675555164A8D491DA','',710554,23,'',NULL), +(774,191,'BECE667BF9443EF6515E8E154F74FC2C5817455C8636DB72','',501956,48,'',NULL), +(775,191,'94F1DA3E0D955761826D6BC932E26F44D321B4838C7567D8','',13538,15,'',NULL), +(776,191,'EA3A3AD71FD14B038C98F256E80C1EFA1F45562A3DF92E7D','',22792,25,'',NULL), +(777,191,'AD5A8CBF55EC436DA968EE0B9744C93F65D9E0D6E3C1B136','',174688,37,'',NULL), +(778,191,'9B6B3B311BA9007C06CF0D146BB979B11CF295C58768DD4F','',31924,23,'',NULL), +(779,217,'','RPE.DLL',0,0,'','rEdoX Packet Editor - injected dll'), +(780,243,'','',5345728,2,'558B','Lua Protection Remover'), +(781,243,'','',7726137,2,'7414','Walk on Water Patch'), +(782,243,'','',8016620,2,'7417','Collision M2 Special'), +(783,243,'','',8016079,6,'0F8462010000','Collision M2 Regular'), +(784,243,'','',8054762,2,'7506','Collision WMD'), +(785,243,'','',9995315,2,'7544','Multi-Jump Patch'), +(786,217,'','WPESPY.DLL',0,0,'','WPE PRO - injected dll'); diff --git a/sql/updates/world/2012_02_19_04_world_misc_db_updates.sql b/sql/updates/world/2012_02_19_04_world_misc_db_updates.sql new file mode 100644 index 000000000..32fada1e8 --- /dev/null +++ b/sql/updates/world/2012_02_19_04_world_misc_db_updates.sql @@ -0,0 +1,21 @@ +-- Horde Orphan should not have weapons +UPDATE `creature_template` SET `equipment_id`=0 WHERE `entry`=14499; +-- Tog'thar Gossip +UPDATE `creature_template` SET `gossip_menu_id`=264 WHERE `entry`=2238; +DELETE FROM `gossip_menu` WHERE `entry`=264 AND `text_id`=761; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (264,761); +-- Cosmetic Silkwing should have InhabitType 4 +UPDATE `creature_template` SET `InhabitType`=4 WHERE `entry`=21840; +-- Leoroxx +UPDATE `creature_template` SET `gossip_menu_id`=8511 WHERE `entry`=22004; +DELETE FROM `gossip_menu` WHERE `entry`=8511 AND `text_id`=10645; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (8511,10645); +-- Spiritcaller Dohgar +UPDATE `creature_template` SET `gossip_menu_id`=8513 WHERE `entry`=22312; +DELETE FROM `gossip_menu` WHERE `entry`=8513 AND `text_id`=10647; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (8513,10647); +-- Ogrin +UPDATE `creature_template` SET `gossip_menu_id`=9821 WHERE `entry`=22468; +-- Wanted Poster "Blade's Edge Mountains" +DELETE FROM `gossip_menu` WHERE `entry`=8242 AND `text_id`=10257; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (8242,10257); diff --git a/sql/updates/world/2012_02_19_05_world_say_text.sql b/sql/updates/world/2012_02_19_05_world_say_text.sql new file mode 100644 index 000000000..b70385660 --- /dev/null +++ b/sql/updates/world/2012_02_19_05_world_say_text.sql @@ -0,0 +1,7 @@ +-- NPC talk text from sniff +DELETE FROM `creature_text` WHERE `entry`=7604; +INSERT INTO `creature_text` (`entry`,`groupid`,`id`,`text`,`type`,`language`,`probability`,`emote`,`duration`,`sound`,`comment`) VALUES +(7604,0,0, 'What? How dare you say that to me?!?',12,0,100,6,0,0, 'Sergeant Bly'), +(7604,1,0, 'After all we''ve been through? Well, I didn''t like you anyway!!',12,0,100,5,0,0, 'Sergeant Bly'); +-- Remove old text +DELETE FROM `script_texts` WHERE `entry` IN (-1209002,-1209003); diff --git a/sql/updates/world/2012_02_19_06_world_say_text.sql b/sql/updates/world/2012_02_19_06_world_say_text.sql new file mode 100644 index 000000000..f69c4cb86 --- /dev/null +++ b/sql/updates/world/2012_02_19_06_world_say_text.sql @@ -0,0 +1,20 @@ +-- SAI for Erich Lohan +SET @ENTRY=3627; +UPDATE `creature_template` SET `AIName`='SmartAI',`ScriptName`='' WHERE `entry`=@ENTRY; +DELETE FROM `smart_scripts` WHERE (`entryorguid`=@ENTRY AND `source_type`=0); +INSERT INTO `smart_scripts` (`entryorguid`,`source_type`,`id`,`link`,`event_type`,`event_phase_mask`,`event_chance`,`event_flags`,`event_param1`,`event_param2`,`event_param3`,`event_param4`,`action_type`,`action_param1`,`action_param2`,`action_param3`,`action_param4`,`action_param5`,`action_param6`,`target_type`,`target_param1`,`target_param2`,`target_param3`,`target_x`,`target_y`,`target_z`,`target_o`,`comment`) VALUES +(@ENTRY,0,0,0,1,0,100,0,10000,15000,10000,15000,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,'Erich Lohan - OOC - Say random text'); +-- Talk text from sniff +DELETE FROM `creature_text` WHERE `entry`=3627; +INSERT INTO `creature_text` (`entry`,`groupid`,`id`,`text`,`type`,`language`,`probability`,`emote`,`duration`,`sound`,`comment`) VALUES +(3627,0,0, 'Magical studies stressing your brain? Relax at the Blue Recluse!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,1, 'Best drinks in Stormwind!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,2, 'Come for the beer, stay for the atmosphere!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,3, 'The only place in Stormwind where magic and spirits mix, come to the Blue Recluse!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,4, 'Free drinks at the Blue Recluse!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,5, 'Feeling blue? Come on down to the Blue Recluse for a good time!',12,7,100,0,0,0, 'Erich Lohan'), +(3627,0,6, 'Head on over to the Blue Recluse. Where everybody knows your name!',12,7,100,0,0,0, 'Erich Lohan'); +-- Remove old waypoint text +UPDATE `waypoint_data` SET `action`=0 WHERE `id`=904450; +DELETE FROM `waypoint_scripts` WHERE `id` BETWEEN 432 AND 446; +DELETE FROM `db_script_string` WHERE `entry` BETWEEN 2000005185 AND 2000005199; diff --git a/sql/updates/world/2012_02_20_00_world_sai.sql b/sql/updates/world/2012_02_20_00_world_sai.sql new file mode 100644 index 000000000..44f8ab68d --- /dev/null +++ b/sql/updates/world/2012_02_20_00_world_sai.sql @@ -0,0 +1,4 @@ +UPDATE `smart_scripts` SET `event_param3`=2*60*60*1000, `event_param4`=2*60*60*1000 WHERE `entryorguid`=18481 AND `source_type`=0 AND `id`=0; +UPDATE `smart_scripts` SET `event_flags`=`event_flags`|1 WHERE `entryorguid` IN (-85175,-85176) AND `source_type`=0 AND `id`=5 AND `link`=6; +UPDATE `smart_scripts` SET `event_flags`=`event_flags`|1 WHERE `entryorguid`=30146 AND `source_type`=0 AND `id`=0; +UPDATE `smart_scripts` SET `event_flags`=`event_flags`|0x20 WHERE `entryorguid` IN (-85175,-85176) AND `source_type`=0 AND `id`=2 AND `link`=3; diff --git a/sql/updates/world/2012_02_20_01_world_misc_db.sql b/sql/updates/world/2012_02_20_01_world_misc_db.sql new file mode 100644 index 000000000..f3943ded2 --- /dev/null +++ b/sql/updates/world/2012_02_20_01_world_misc_db.sql @@ -0,0 +1,8 @@ +-- Fix error in Scourge Deathspeaker SAI +UPDATE `smart_scripts` SET `link`=0 WHERE `entryorguid`=27615 AND `id`=14; +-- Fix up Keeper Remulos SAI +UPDATE `smart_scripts` SET `id`=3 WHERE `entryorguid`=11832 AND `id`=4; +-- Spiritcaller Dohgar +UPDATE `creature_template` SET `gossip_menu_id`=8513 WHERE `entry`=22312; +DELETE FROM `gossip_menu` WHERE `entry`=8513 AND `text_id`=10647; +INSERT INTO `gossip_menu` (`entry`,`text_id`) VALUES (8513,10647); diff --git a/sql/updates/world/2012_02_20_02_world_conditons.sql b/sql/updates/world/2012_02_20_02_world_conditons.sql new file mode 100644 index 000000000..832d8dbda --- /dev/null +++ b/sql/updates/world/2012_02_20_02_world_conditons.sql @@ -0,0 +1,275 @@ +# Update a typo in original data entry +UPDATE `npc_spellclick_spells` SET `quest_end`=11999 WHERE `npc_entry`=26477 AND `spell_id`=61832 AND `quest_start`=11999; +# Delete redundant data with invalid condition type +DELETE FROM `conditions` WHERE `SourceTypeOrReferenceId`=18; + +# Static Data +INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`, +`ElseGroup`,`ConditionTypeOrReference`,`ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`ConditionValue3`,`NegativeCondition`,`Comment`) VALUES +(18,24752,44363,0,8,0,11460,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,24752,44363,0,9,0,11460,0,0,0,'Required quest active for spellclick'), +(18,25596,45875,0,8,0,11690,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,25596,45875,0,9,0,11690,0,0,0,'Required quest active for spellclick'), +(18,25841,46166,0,8,0,11795,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,25841,46166,0,9,0,11795,0,0,0,'Required quest active for spellclick'), +(18,26200,39996,0,8,0,11960,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26200,39996,0,9,0,11960,0,0,0,'Required quest active for spellclick'), +(18,26200,61286,0,8,0,11960,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26200,61286,0,9,0,11960,0,0,0,'Required quest active for spellclick'), +(18,26421,47575,0,8,0,12092,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26421,47575,0,8,0,12096,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26421,47575,0,9,0,12092,0,0,0,'Required quest active for spellclick'), +(18,26421,47575,0,9,0,12096,0,0,0,'Required quest active for spellclick'), +(18,26477,47096,0,8,0,11999,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,47096,0,8,0,12000,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,47096,0,9,0,11999,0,0,0,'Required quest active for spellclick'), +(18,26477,47096,0,9,0,12000,0,0,0,'Required quest active for spellclick'), +(18,26477,61286,0,8,0,11999,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,61286,0,8,0,12000,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,61286,0,9,0,11999,0,0,0,'Required quest active for spellclick'), +(18,26477,61286,0,9,0,12000,0,0,0,'Required quest active for spellclick'), +(18,26477,61832,0,8,0,11999,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,61832,0,8,0,12000,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,26477,61832,0,9,0,11999,0,0,0,'Required quest active for spellclick'), +(18,26477,61832,0,9,0,12000,0,0,0,'Required quest active for spellclick'), +(18,27061,47920,0,8,0,12050,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,27061,47920,0,9,0,12050,0,0,0,'Required quest active for spellclick'), +(18,27354,60944,18,8,0,12244,0,0,0,'Required quest rewarded for spellclick'), +(18,27354,60944,18,9,0,12244,0,0,0,'Required quest active for spellclick'), +(18,28161,39996,0,8,0,12532,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,39996,0,8,0,12702,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,39996,0,9,0,12532,0,0,0,'Required quest active for spellclick'), +(18,28161,39996,0,9,0,12702,0,0,0,'Required quest active for spellclick'), +(18,28161,51037,0,8,0,12532,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,51037,0,8,0,12702,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,51037,0,9,0,12532,0,0,0,'Required quest active for spellclick'), +(18,28161,51037,0,9,0,12702,0,0,0,'Required quest active for spellclick'), +(18,28161,51961,0,8,0,12532,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,51961,0,8,0,12702,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28161,51961,0,9,0,12532,0,0,0,'Required quest active for spellclick'), +(18,28161,51961,0,9,0,12702,0,0,0,'Required quest active for spellclick'), +(18,28162,39996,0,8,0,12519,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28162,39996,0,9,0,12519,0,0,0,'Required quest active for spellclick'), +(18,28162,50737,0,8,0,12519,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28162,50737,0,9,0,12519,0,0,0,'Required quest active for spellclick'), +(18,28162,51026,0,8,0,12519,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28162,51026,0,9,0,12519,0,0,0,'Required quest active for spellclick'), +(18,28162,61286,0,8,0,12519,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28162,61286,0,9,0,12519,0,0,0,'Required quest active for spellclick'), +(18,28202,50926,0,8,0,12527,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28202,50926,0,9,0,12527,0,0,0,'Required quest active for spellclick'), +(18,28202,50927,0,8,0,12527,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28202,50927,0,9,0,12527,0,0,0,'Required quest active for spellclick'), +(18,28203,50918,0,8,0,12527,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28203,50918,0,9,0,12527,0,0,0,'Required quest active for spellclick'), +(18,28203,50919,0,8,0,12527,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28203,50919,0,9,0,12527,0,0,0,'Required quest active for spellclick'), +(18,28222,52082,0,8,0,12546,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28222,52082,0,9,0,12546,0,0,0,'Required quest active for spellclick'), +(18,28379,51658,0,8,0,12607,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28379,51658,0,9,0,12607,0,0,0,'Required quest active for spellclick'), +(18,28389,51592,0,8,0,12605,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28389,51592,0,9,0,12605,0,0,0,'Required quest active for spellclick'), +(18,28389,51593,0,8,0,12605,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28389,51593,0,9,0,12605,0,0,0,'Required quest active for spellclick'), +(18,28782,52280,0,8,0,12687,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,28782,52280,0,9,0,12687,0,0,0,'Required quest active for spellclick'), +(18,29488,54568,15,8,0,12670,0,0,0,'Required quest rewarded for spellclick'), +(18,29488,54568,15,9,0,12670,0,0,0,'Required quest active for spellclick'), +(18,29563,56795,0,8,0,1,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29598,54768,0,8,0,12856,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29708,55028,0,8,0,12856,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29708,55028,0,9,0,12856,0,0,0,'Required quest active for spellclick'), +(18,29856,55363,0,8,0,12629,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29856,55363,0,8,0,12643,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29856,55363,0,9,0,12629,0,0,0,'Required quest active for spellclick'), +(18,29856,55363,0,9,0,12643,0,0,0,'Required quest active for spellclick'), +(18,29857,55457,0,8,0,12910,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,29857,55457,0,9,0,12910,0,0,0,'Required quest active for spellclick'), +(18,30066,43977,0,8,0,12953,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,30337,43671,0,8,0,13069,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,30337,43671,0,9,0,13069,0,0,0,'Required quest active for spellclick'), +(18,30500,56679,0,8,0,13045,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,30500,56679,0,9,0,13045,0,0,0,'Required quest active for spellclick'), +(18,30560,57347,0,1,0,57348,0,0,1,'Forbidden aura for spellclick'), +(18,31736,59592,0,8,0,13280,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,31736,59592,0,9,0,13280,0,0,0,'Required quest active for spellclick'), +(18,31785,59656,0,8,0,13283,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,31785,59656,0,9,0,13283,0,0,0,'Required quest active for spellclick'), +(18,31883,60123,0,1,0,48085,0,0,1,'Forbidden aura for spellclick'), +(18,31893,60123,0,1,0,48084,0,0,1,'Forbidden aura for spellclick'), +(18,31894,60123,0,1,0,28276,0,0,1,'Forbidden aura for spellclick'), +(18,31895,60123,0,1,0,27874,0,0,1,'Forbidden aura for spellclick'), +(18,31896,60123,0,1,0,27873,0,0,1,'Forbidden aura for spellclick'), +(18,31897,60123,0,1,0,7001,0,0,1,'Forbidden aura for spellclick'), +(18,32788,57539,17,8,0,13075,0,0,0,'Required quest rewarded for spellclick'), +(18,32788,57539,17,9,0,13075,0,0,0,'Required quest active for spellclick'), +(18,32790,57654,16,8,0,13073,0,0,0,'Required quest rewarded for spellclick'), +(18,32790,57654,16,9,0,13073,0,0,0,'Required quest active for spellclick'), +(18,33498,63126,0,8,0,13654,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,33498,63126,0,9,0,13654,0,0,0,'Required quest active for spellclick'), +(18,33790,62781,0,8,0,13690,0,0,0,'Required quest rewarded for spellclick'), +(18,33790,62781,0,8,0,13705,0,0,0,'Required quest rewarded for spellclick'), +(18,33791,62786,0,8,0,13696,0,0,0,'Required quest rewarded for spellclick'), +(18,33791,62786,0,8,0,13711,0,0,0,'Required quest rewarded for spellclick'), +(18,33792,62785,0,8,0,13694,0,0,0,'Required quest rewarded for spellclick'), +(18,33792,62785,0,8,0,13709,0,0,0,'Required quest rewarded for spellclick'), +(18,33793,62780,0,8,0,13688,0,0,0,'Required quest rewarded for spellclick'), +(18,33793,62780,0,8,0,13704,0,0,0,'Required quest rewarded for spellclick'), +(18,33794,62782,0,8,0,13689,0,0,0,'Required quest rewarded for spellclick'), +(18,33794,62782,0,8,0,13706,0,0,0,'Required quest rewarded for spellclick'), +(18,33795,62779,0,8,0,13685,0,0,0,'Required quest rewarded for spellclick'), +(18,33795,62779,0,8,0,13703,0,0,0,'Required quest rewarded for spellclick'), +(18,33796,62784,0,8,0,13693,0,0,0,'Required quest rewarded for spellclick'), +(18,33796,62784,0,8,0,13708,0,0,0,'Required quest rewarded for spellclick'), +(18,33798,62787,0,8,0,13695,0,0,0,'Required quest rewarded for spellclick'), +(18,33798,62787,0,8,0,13710,0,0,0,'Required quest rewarded for spellclick'), +(18,33799,62783,0,8,0,13691,0,0,0,'Required quest rewarded for spellclick'), +(18,33799,62783,0,8,0,13707,0,0,0,'Required quest rewarded for spellclick'), +(18,33800,62774,0,8,0,13593,0,0,0,'Required quest rewarded for spellclick'), +(18,33800,62774,0,8,0,13684,0,0,0,'Required quest rewarded for spellclick'), +(18,33842,63791,0,8,0,13668,0,0,0,'Required quest rewarded for spellclick'), +(18,33842,63791,0,8,0,13687,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,33843,63792,0,8,0,13667,0,0,0,'Required quest rewarded for spellclick'), +(18,33843,63792,0,8,0,13686,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,33870,63663,0,8,0,1,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13847,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13851,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13852,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13854,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13855,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13856,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13857,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13858,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13859,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13860,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13861,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13862,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13863,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,8,0,13864,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,34125,63215,0,9,0,13847,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13851,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13852,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13854,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13855,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13856,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13857,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13858,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13859,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13860,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13861,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13862,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13863,0,0,0,'Required quest active for spellclick'), +(18,34125,63215,0,9,0,13864,0,0,0,'Required quest active for spellclick'), +(18,38248,71462,0,1,0,71443,0,0,1,'Forbidden aura for spellclick'), +(18,40176,74904,0,8,0,25444,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,40176,74904,0,9,0,25444,0,0,0,'Required quest active for spellclick'), +(18,40176,74905,0,8,0,25444,0,0,1,'Forbidden rewarded quest for spellclick'), +(18,40176,74905,0,9,0,25444,0,0,0,'Required quest active for spellclick'); + +# Below is a procedure to dynamically convert custom content to conditions table. +# However this procedure only works for MySQL server versions >= 5.6 due to +# a bug / missing feature in older MySQL versions. +/* + +DROP PROCEDURE IF EXISTS ConvertSpellClickConditions; +DELIMITER // +CREATE PROCEDURE ConvertSpellClickConditions() +BEGIN + DECLARE counter INT DEFAULT 0; + DECLARE recordCount INT DEFAULT 0; + DECLARE counterPlusOne INT DEFAULT 0; + DECLARE npcEntry INT DEFAULT 0; + DECLARE spellId INT DEFAULT 0; + DECLARE aura INT DEFAULT 0; + DECLARE quest INT DEFAULT 0; + DECLARE quest2 INT DEFAULT 0; + DECLARE questStartCanActive INT DEFAULT 0; + DECLARE maxElseGroupId INT DEFAULT 14; # Change this for custom content + SELECT COUNT(*) INTO recordCount FROM `npc_spellclick_spells` WHERE `aura_required` !=0; + WHILE counter < recordCount DO + SELECT `npc_entry`, `spell_id`, `aura_required` + INTO npcEntry, spellId, aura + FROM `npc_spellclick_spells` WHERE `aura_required` !=0 + LIMIT counter,1; + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,1,0,aura,0,0,'Required aura for spellclick'); + SET counter = counter+1; + END WHILE; + + SET counter = 0; + SET recordCount = 0; + SELECT COUNT(*) INTO recordCount FROM `npc_spellclick_spells` WHERE `aura_forbidden` !=0; + WHILE counter < recordCount DO + SELECT `npc_entry`, `spell_id`, `aura_forbidden` + INTO npcEntry, spellId, aura + FROM `npc_spellclick_spells` WHERE `aura_forbidden` !=0 + LIMIT counter,1; + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,1,0,aura,0,1,'Forbidden aura for spellclick'); + SET counter = counter+1; + END WHILE; + + SET counter = 0; + SET recordCount = 0; + SELECT COUNT(*) INTO recordCount FROM `npc_spellclick_spells` WHERE `quest_start` !=0; + WHILE counter < recordCount DO + SELECT `npc_entry`, `spell_id`, `quest_start`, `quest_start_active`, `quest_end` + INTO npcEntry, spellId, quest, questStartCanActive, quest2 + FROM `npc_spellclick_spells` WHERE `quest_start` !=0 + LIMIT counter,1; + IF questStartCanActive = 1 AND quest2 = 0 THEN + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`, `ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,maxElseGroupId+1,9,0,quest,0,0,'Required quest active for spellclick'); + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ElseGroup`, `ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,maxElseGroupId+1,8,0,quest,0,0,'Required quest rewarded for spellclick'); + SET maxElseGroupId = maxElseGroupId+1; + # ELSE IF quest2 != 0 is handled in next loop (forbidden rewarded quest) + ELSEIF questStartCanActive = 1 && quest2 = quest THEN + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,9,0,quest,0,0,'Required quest active for spellclick'); + # ^Adds the required active quest condition. Prohibit quest reward is done in next loop + ELSEIF questStartCanActive = 0 THEN + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,8,0,quest,0,0,'Required quest rewarded for spellclick'); + END IF; + + SET counter = counter+1; + END WHILE; + + SET counter = 0; + SET recordCount = 0; + SELECT COUNT(*) INTO recordCount FROM `npc_spellclick_spells` WHERE `quest_end` !=0; + WHILE counter < recordCount DO + SELECT `npc_entry`, `spell_id`, `quest_end` + INTO npcEntry, spellId, quest + FROM `npc_spellclick_spells` WHERE `quest_end` !=0 + LIMIT counter,1; + INSERT INTO `conditions` (`SourceTypeOrReferenceId`,`SourceGroup`,`SourceEntry`,`ConditionTypeOrReference`, + `ConditionTarget`,`ConditionValue1`,`ConditionValue2`,`NegativeCondition`,`Comment`) + VALUES (18,npcEntry,spellId,8,0,quest,0,1,'Forbidden rewarded quest for spellclick'); + SET counter = counter+1; + END WHILE; + +END// + +DELIMITER ; + +CALL ConvertSpellClickConditions(); +DROP PROCEDURE ConvertSpellClickConditions; + +*/ + +ALTER TABLE `npc_spellclick_spells` + DROP COLUMN `quest_start`, + DROP COLUMN `quest_start_active`, + DROP COLUMN `quest_end`, + DROP COLUMN `aura_required`, + DROP COLUMN `aura_forbidden` +; diff --git a/src/server/authserver/Server/AuthSocket.cpp b/src/server/authserver/Server/AuthSocket.cpp index 6d295a0bb..e1d77c602 100755 --- a/src/server/authserver/Server/AuthSocket.cpp +++ b/src/server/authserver/Server/AuthSocket.cpp @@ -16,6 +16,7 @@ * with this program. If not, see . */ +#include #include #include "Common.h" @@ -343,6 +344,13 @@ bool AuthSocket::_HandleLogonChallenge() _login = (const char*)ch->I; _build = ch->build; _expversion = (AuthHelper::IsPostBCAcceptedClientBuild(_build) ? POST_BC_EXP_FLAG : NO_VALID_EXP_FLAG) | (AuthHelper::IsPreBCAcceptedClientBuild(_build) ? PRE_BC_EXP_FLAG : NO_VALID_EXP_FLAG); + _os = (const char*)ch->os; + + if (_os.size() > 4) + return false; + + // Restore string order as its byte order is reversed + std::reverse(_os.begin(), _os.end()); pkt << (uint8)AUTH_LOGON_CHALLENGE; pkt << (uint8)0x00; @@ -602,7 +610,8 @@ bool AuthSocket::_HandleLogonProof() stmt->setString(0, K_hex); stmt->setString(1, socket().getRemoteAddress().c_str()); stmt->setUInt32(2, GetLocaleByName(_localizationName)); - stmt->setString(3, _login); + stmt->setString(3, _os); + stmt->setString(4, _login); LoginDatabase.Execute(stmt); OPENSSL_free((void*)K_hex); @@ -741,6 +750,13 @@ bool AuthSocket::_HandleReconnectChallenge() // Reinitialize build, expansion and the account securitylevel _build = ch->build; _expversion = (AuthHelper::IsPostBCAcceptedClientBuild(_build) ? POST_BC_EXP_FLAG : NO_VALID_EXP_FLAG) | (AuthHelper::IsPreBCAcceptedClientBuild(_build) ? PRE_BC_EXP_FLAG : NO_VALID_EXP_FLAG); + _os = (const char*)ch->os; + + if (_os.size() > 4) + return false; + + // Restore string order as its byte order is reversed + std::reverse(_os.begin(), _os.end()); Field* fields = result->Fetch(); uint8 secLevel = fields[2].GetUInt8(); diff --git a/src/server/authserver/Server/AuthSocket.h b/src/server/authserver/Server/AuthSocket.h index 490b0db21..9d59a9f76 100755 --- a/src/server/authserver/Server/AuthSocket.h +++ b/src/server/authserver/Server/AuthSocket.h @@ -81,6 +81,7 @@ private: // Since GetLocaleByName() is _NOT_ bijective, we have to store the locale as a string. Otherwise we can't differ // between enUS and enGB, which is important for the patch system std::string _localizationName; + std::string _os; uint16 _build; uint8 _expversion; AccountTypes _accountSecurityLevel; diff --git a/src/server/authserver/Server/RealmSocket.cpp b/src/server/authserver/Server/RealmSocket.cpp index 72c36fc66..e839457d1 100755 --- a/src/server/authserver/Server/RealmSocket.cpp +++ b/src/server/authserver/Server/RealmSocket.cpp @@ -95,7 +95,7 @@ const std::string& RealmSocket::getRemoteAddress(void) const return _remoteAddress; } -const uint16 RealmSocket::getRemotePort(void) const +uint16 RealmSocket::getRemotePort(void) const { return _remotePort; } diff --git a/src/server/authserver/Server/RealmSocket.h b/src/server/authserver/Server/RealmSocket.h index 9dbd0a4aa..c03a0e3ad 100755 --- a/src/server/authserver/Server/RealmSocket.h +++ b/src/server/authserver/Server/RealmSocket.h @@ -55,7 +55,7 @@ public: const std::string& getRemoteAddress(void) const; - const uint16 getRemotePort(void) const; + uint16 getRemotePort(void) const; virtual int open(void *); diff --git a/src/server/collision/BoundingIntervalHierarchyWrapper.h b/src/server/collision/BoundingIntervalHierarchyWrapper.h index e54a4e653..e2252ca60 100644 --- a/src/server/collision/BoundingIntervalHierarchyWrapper.h +++ b/src/server/collision/BoundingIntervalHierarchyWrapper.h @@ -34,7 +34,7 @@ class BIHWrap const T* const* objects; RayCallback& _callback; - MDLCallback(RayCallback& callback, const T* const* objects_array ) : _callback(callback), objects(objects_array){} + MDLCallback(RayCallback& callback, const T* const* objects_array ) : objects(objects_array), _callback(callback) {} bool operator() (const Ray& ray, uint32 Idx, float& MaxDist, bool /*stopAtFirst*/) { @@ -106,4 +106,4 @@ public: } }; -#endif // _BIH_WRAP \ No newline at end of file +#endif // _BIH_WRAP diff --git a/src/server/collision/DynamicTree.cpp b/src/server/collision/DynamicTree.cpp index 89e76d426..ebb46614a 100644 --- a/src/server/collision/DynamicTree.cpp +++ b/src/server/collision/DynamicTree.cpp @@ -43,10 +43,11 @@ template<> struct BoundsTrait< GameObjectModel> { static void getBounds2(const GameObjectModel* g, G3D::AABox& out) { out = g->getBounds();} }; +/* static bool operator == (const GameObjectModel& mdl, const GameObjectModel& mdl2){ return &mdl == &mdl2; } - +*/ int valuesPerNode = 5, numMeanSplits = 3; @@ -251,4 +252,4 @@ float DynamicMapTree::getHeight(float x, float y, float z, float maxSearchDist, return v.z - maxSearchDist; else return -G3D::inf(); -} \ No newline at end of file +} diff --git a/src/server/collision/DynamicTree.h b/src/server/collision/DynamicTree.h index 0b4f5908c..079c0adbf 100644 --- a/src/server/collision/DynamicTree.h +++ b/src/server/collision/DynamicTree.h @@ -16,7 +16,7 @@ * with this program. If not, see . */ - + #ifndef _DYNTREE_H #define _DYNTREE_H diff --git a/src/server/collision/Maps/TileAssembler.cpp b/src/server/collision/Maps/TileAssembler.cpp index 62968e4de..68ea3ec80 100644 --- a/src/server/collision/Maps/TileAssembler.cpp +++ b/src/server/collision/Maps/TileAssembler.cpp @@ -258,7 +258,7 @@ namespace VMAP uint32 groups = raw_model.groupsArray.size(); if (groups != 1) printf("Warning: '%s' does not seem to be a M2 model!\n", modelFilename.c_str()); - + AABox modelBound; bool boundEmpty=true; @@ -308,7 +308,7 @@ namespace VMAP WorldModel_Raw raw_model; if (!raw_model.Read(filename.c_str())) return false; - + // write WorldModel WorldModel model; model.setRootWmoID(raw_model.RootWMOID); @@ -327,12 +327,12 @@ namespace VMAP model.setGroupModels(groupsArray); } - + success = model.writeFile(iDestDir + "/" + pModelFilename + ".vmo"); //std::cout << "readRawFile2: '" << pModelFilename << "' tris: " << nElements << " nodes: " << nNodes << std::endl; return success; } - + void TileAssembler::exportGameobjectModels() { FILE* model_list = fopen((iSrcDir + "/" + GAMEOBJECT_MODELS).c_str(), "rb"); @@ -344,16 +344,15 @@ namespace VMAP char buff[500]; while (!feof(model_list)) { - fread(&displayId,sizeof(uint32),1,model_list); - fread(&name_length,sizeof(uint32),1,model_list); - - if (name_length >= sizeof(buff)) + if (fread(&displayId, sizeof(uint32), 1, model_list) != 1 + || fread(&name_length, sizeof(uint32), 1, model_list) != 1 + || name_length >= sizeof(buff) + || fread(&buff, sizeof(char), name_length, model_list) != name_length) { std::cout << "\nFile 'temp_gameobject_models' seems to be corrupted" << std::endl; break; } - fread(&buff,sizeof(char),name_length,model_list); std::string model_name(buff, name_length); WorldModel_Raw raw_model; @@ -406,13 +405,13 @@ namespace VMAP READ_OR_RETURN(&mogpflags, sizeof(uint32)); READ_OR_RETURN(&GroupWMOID, sizeof(uint32)); - + Vector3 vec1, vec2; READ_OR_RETURN(&vec1, sizeof(Vector3)); READ_OR_RETURN(&vec2, sizeof(Vector3)); bounds.set(vec1, vec2); - + READ_OR_RETURN(&liquidflags, sizeof(uint32)); // will this ever be used? what is it good for anyway?? @@ -476,7 +475,7 @@ namespace VMAP size = hlq.xtiles*hlq.ytiles; READ_OR_RETURN(liquid->GetFlagsStorage(), size); } - + return true; } @@ -485,7 +484,7 @@ namespace VMAP { delete liquid; } - + bool WorldModel_Raw::Read(const char * path) { FILE* rf = fopen(path, "rb"); @@ -494,7 +493,7 @@ namespace VMAP printf("ERROR: Can't open raw model file: %s\n", path); return false; } - + char ident[8]; int readOperation = 0; diff --git a/src/server/collision/Models/GameObjectModel.cpp b/src/server/collision/Models/GameObjectModel.cpp index 5ad984fcb..1abbc59a5 100644 --- a/src/server/collision/Models/GameObjectModel.cpp +++ b/src/server/collision/Models/GameObjectModel.cpp @@ -15,7 +15,7 @@ * You should have received a copy of the GNU General Public License along * with this program. If not, see . */ - + #include "VMapFactory.h" #include "VMapManager2.h" #include "VMapDefinitions.h" @@ -36,7 +36,7 @@ using G3D::AABox; struct GameobjectModelData { GameobjectModelData(const std::string& name_, const AABox& box) : - name(name_), bound(box) {} + bound(box), name(name_) {} AABox bound; std::string name; @@ -55,20 +55,18 @@ void LoadGameObjectModelList() char buff[500]; while (!feof(model_list_file)) { - fread(&displayId,sizeof(uint32),1,model_list_file); - fread(&name_length,sizeof(uint32),1,model_list_file); - - if (name_length >= sizeof(buff)) + Vector3 v1, v2; + if (fread(&displayId, sizeof(uint32), 1, model_list_file) != 1 + || fread(&name_length, sizeof(uint32), 1, model_list_file) != 1 + || name_length >= sizeof(buff) + || fread(&buff, sizeof(char), name_length, model_list_file) != name_length + || fread(&v1, sizeof(Vector3), 1, model_list_file) != 1 + || fread(&v2, sizeof(Vector3), 1, model_list_file) != 1) { printf("\nFile '%s' seems to be corrupted", VMAP::GAMEOBJECT_MODELS); break; } - fread(&buff, sizeof(char), name_length,model_list_file); - Vector3 v1, v2; - fread(&v1, sizeof(Vector3), 1, model_list_file); - fread(&v2, sizeof(Vector3), 1, model_list_file); - model_list.insert ( ModelList::value_type( displayId, GameobjectModelData(std::string(buff,name_length),AABox(v1,v2)) ) @@ -172,4 +170,4 @@ bool GameObjectModel::intersectRay(const G3D::Ray& ray, float& MaxDist, bool Sto MaxDist = distance; } return hit; -} \ No newline at end of file +} diff --git a/src/server/collision/Models/GameObjectModel.h b/src/server/collision/Models/GameObjectModel.h index 413061c0d..0bb6c0f47 100644 --- a/src/server/collision/Models/GameObjectModel.h +++ b/src/server/collision/Models/GameObjectModel.h @@ -15,7 +15,7 @@ * You should have received a copy of the GNU General Public License along * with this program. If not, see . */ - + #ifndef _GAMEOBJECT_MODEL_H #define _GAMEOBJECT_MODEL_H @@ -57,7 +57,7 @@ public: const G3D::Vector3& getPosition() const { return iPos;} - /** Enables\disables collision. */ + /** Enables\disables collision. */ void disable() { phasemask = 0;} void enable(uint32 ph_mask) { phasemask = ph_mask;} diff --git a/src/server/collision/Models/WorldModel.cpp b/src/server/collision/Models/WorldModel.cpp index b49538a48..cda345100 100644 --- a/src/server/collision/Models/WorldModel.cpp +++ b/src/server/collision/Models/WorldModel.cpp @@ -17,6 +17,7 @@ */ #include "WorldModel.h" +#include "ModelInstance.h" #include "VMapDefinitions.h" #include "MapTree.h" diff --git a/src/server/collision/RegularGrid.h b/src/server/collision/RegularGrid.h index be61504bc..2867b29cf 100644 --- a/src/server/collision/RegularGrid.h +++ b/src/server/collision/RegularGrid.h @@ -17,7 +17,7 @@ using G3D::Ray; template struct NodeCreator{ - static Node * makeNode(int x, int y) { return new Node();} + static Node * makeNode(int /*x*/, int /*y*/) { return new Node();} }; template= 0) { stepX = 1; @@ -215,4 +215,4 @@ public: #undef CELL_SIZE #undef HGRID_MAP_SIZE -#endif \ No newline at end of file +#endif diff --git a/src/server/game/AI/CoreAI/CombatAI.cpp b/src/server/game/AI/CoreAI/CombatAI.cpp index d8def36f9..86f2c6a28 100755 --- a/src/server/game/AI/CoreAI/CombatAI.cpp +++ b/src/server/game/AI/CoreAI/CombatAI.cpp @@ -326,7 +326,7 @@ void VehicleAI::CheckConditions(const uint32 diff) { if (Player* player = passenger->ToPlayer()) { - if (!sConditionMgr->IsObjectMeetToConditions(player, conditions)) + if (!sConditionMgr->IsObjectMeetToConditions(player, me, conditions)) { player->ExitVehicle(); return;//check other pessanger in next tick diff --git a/src/server/game/AI/SmartScripts/SmartAI.cpp b/src/server/game/AI/SmartScripts/SmartAI.cpp index 07a8e3fdc..7838e6891 100644 --- a/src/server/game/AI/SmartScripts/SmartAI.cpp +++ b/src/server/game/AI/SmartScripts/SmartAI.cpp @@ -450,7 +450,7 @@ void SmartAI::EnterEvadeMode() return; RemoveAuras(); - + me->DeleteThreatList(); me->CombatStop(true); me->LoadCreaturesAddon(); @@ -480,15 +480,15 @@ void SmartAI::MoveInLineOfSight(Unit* who) { if (!who) return; - + GetScript()->OnMoveInLineOfSight(who); - + if (me->HasReactState(REACT_PASSIVE) || AssistPlayerInCombat(who)) return; if (!CanAIAttack(who)) return; - + if (!me->canStartAttack(who, false)) return; @@ -827,7 +827,7 @@ void SmartAI::SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker) GetScript()->mLastInvoker = invoker->GetGUID(); GetScript()->SetScript9(e, entry); } - + void SmartAI::sOnGameEvent(bool start, uint16 eventId) { GetScript()->ProcessEventsFor(start ? SMART_EVENT_GAME_EVENT_START : SMART_EVENT_GAME_EVENT_END, NULL, eventId); diff --git a/src/server/game/AI/SmartScripts/SmartAI.h b/src/server/game/AI/SmartScripts/SmartAI.h index a40254fe3..e82b35ec8 100644 --- a/src/server/game/AI/SmartScripts/SmartAI.h +++ b/src/server/game/AI/SmartScripts/SmartAI.h @@ -195,7 +195,7 @@ class SmartAI : public CreatureAI mDespawnState = t ? 1 : 0; } void StartDespawn() { mDespawnState = 2; } - + void RemoveAuras(); private: diff --git a/src/server/game/AI/SmartScripts/SmartScript.cpp b/src/server/game/AI/SmartScripts/SmartScript.cpp index c71674137..95574e6d2 100644 --- a/src/server/game/AI/SmartScripts/SmartScript.cpp +++ b/src/server/game/AI/SmartScripts/SmartScript.cpp @@ -88,7 +88,7 @@ void SmartScript::ProcessEventsFor(SMART_EVENT e, Unit* unit, uint32 var0, uint3 ConditionList conds = sConditionMgr->GetConditionsForSmartEvent((*i).entryOrGuid, (*i).event_id, (*i).source_type); ConditionSourceInfo info = ConditionSourceInfo(unit, GetBaseObject()); meets = sConditionMgr->IsObjectMeetToConditions(info, conds); - + if (meets) ProcessEvent(*i, unit, var0, var1, bvar, spell, gob); } @@ -479,7 +479,10 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u if (e.action.cast.flags & SMARTCAST_INTERRUPT_PREVIOUS) me->InterruptNonMeleeSpells(false); - me->CastSpell((*itr)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + if (!(e.action.cast.flags & SMARTCAST_AURA_NOT_PRESENT) || !(*itr)->ToUnit()->HasAura(e.action.cast.spell)) + me->CastSpell((*itr)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + else + sLog->outDebug(LOG_FILTER_DATABASE_AI, "Spell %u not casted because it has flag SMARTCAST_AURA_NOT_PRESENT and the target (Guid: %u Entry: %u Type: %u) already has the aura", e.action.cast.spell, (*itr)->GetGUID(), (*itr)->GetEntry(), uint32((*itr)->GetTypeId())); sLog->outDebug(LOG_FILTER_DATABASE_AI, "SmartScript::ProcessAction:: SMART_ACTION_CAST:: Creature %u casts spell %u on target %u with castflags %u", me->GetGUIDLow(), e.action.cast.spell, (*itr)->GetGUIDLow(), e.action.cast.flags); } @@ -505,7 +508,11 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u if (e.action.cast.flags & SMARTCAST_INTERRUPT_PREVIOUS) tempLastInvoker->InterruptNonMeleeSpells(false); - tempLastInvoker->CastSpell((*itr)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + if (!(e.action.cast.flags & SMARTCAST_AURA_NOT_PRESENT) || !(*itr)->ToUnit()->HasAura(e.action.cast.spell)) + tempLastInvoker->CastSpell((*itr)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + else + sLog->outDebug(LOG_FILTER_DATABASE_AI, "Spell %u not casted because it has flag SMARTCAST_AURA_NOT_PRESENT and the target (Guid: %u Entry: %u Type: %u) already has the aura", e.action.cast.spell, (*itr)->GetGUID(), (*itr)->GetEntry(), uint32((*itr)->GetTypeId())); + sLog->outDebug(LOG_FILTER_DATABASE_AI, "SmartScript::ProcessAction:: SMART_ACTION_INVOKER_CAST: Invoker %u casts spell %u on target %u with castflags %u", tempLastInvoker->GetGUIDLow(), e.action.cast.spell, (*itr)->GetGUIDLow(), e.action.cast.flags); } @@ -1563,8 +1570,15 @@ void SmartScript::ProcessAction(SmartScriptHolder& e, Unit* unit, uint32 var0, u (*itr)->ToUnit()->InterruptNonMeleeSpells(false); for (ObjectList::const_iterator it = targets->begin(); it != targets->end(); ++it) + { if (IsUnit(*it)) - (*itr)->ToUnit()->CastSpell((*it)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + { + if (!(e.action.cast.flags & SMARTCAST_AURA_NOT_PRESENT) || !(*it)->ToUnit()->HasAura(e.action.cast.spell)) + (*itr)->ToUnit()->CastSpell((*it)->ToUnit(), e.action.cast.spell, (e.action.cast.flags & SMARTCAST_TRIGGERED) ? true : false); + else + sLog->outDebug(LOG_FILTER_DATABASE_AI, "Spell %u not casted because it has flag SMARTCAST_AURA_NOT_PRESENT and the target (Guid: %u Entry: %u Type: %u) already has the aura", e.action.cast.spell, (*it)->GetGUID(), (*it)->GetEntry(), uint32((*it)->GetTypeId())); + } + } } } diff --git a/src/server/game/AI/SmartScripts/SmartScriptMgr.cpp b/src/server/game/AI/SmartScripts/SmartScriptMgr.cpp index 9a23d9e13..f99e31745 100644 --- a/src/server/game/AI/SmartScripts/SmartScriptMgr.cpp +++ b/src/server/game/AI/SmartScripts/SmartScriptMgr.cpp @@ -260,7 +260,7 @@ bool SmartAIMgr::IsTargetValid(SmartScriptHolder const& e) } case SMART_TARGET_GAMEOBJECT_GUID: { - if (e.target.goGUID.entry && !IsGameObjectValid(e, e.target.goGUID.entry)) + if (e.target.goGUID.entry && !IsGameObjectValid(e, e.target.goGUID.entry)) return false; break; } diff --git a/src/server/game/AI/SmartScripts/SmartScriptMgr.h b/src/server/game/AI/SmartScripts/SmartScriptMgr.h index e08fe331d..0d182e1be 100644 --- a/src/server/game/AI/SmartScripts/SmartScriptMgr.h +++ b/src/server/game/AI/SmartScripts/SmartScriptMgr.h @@ -154,7 +154,7 @@ enum SMART_EVENT SMART_EVENT_IS_BEHIND_TARGET = 67, //1 // cooldownMin, CooldownMax SMART_EVENT_GAME_EVENT_START = 68, //1 // game_event.Entry SMART_EVENT_GAME_EVENT_END = 69, //1 // game_event.Entry - SMART_EVENT_GO_STATE_CHANGED = 70, // go state + SMART_EVENT_GO_STATE_CHANGED = 70, // go state SMART_EVENT_END = 71, }; @@ -341,16 +341,16 @@ struct SmartEvent uint32 cooldownMax; } behindTarget; - struct + struct { uint32 gameEventId; } gameEvent; - + struct { uint32 state; } goStateChanged; - + struct { uint32 param1; @@ -872,7 +872,7 @@ struct SmartAction { uint32 goRespawnTime; } RespawnTarget; - + struct { uint32 gossipMenuId; @@ -883,12 +883,12 @@ struct SmartAction { uint32 state; } setGoLootState; - + struct { uint32 id; } sendTargetToTarget; - + struct { uint32 param1; @@ -1180,7 +1180,7 @@ enum SmartCastFlags //CAST_FORCE_CAST = 0x04, //Forces cast even if creature is out of mana or out of range //CAST_NO_MELEE_IF_OOM = 0x08, //Prevents creature from entering melee if out of mana or out of range //CAST_FORCE_TARGET_SELF = 0x10, //Forces the target to cast this spell on itself - //CAST_AURA_NOT_PRESENT = 0x20, //Only casts the spell if the target does not have an aura from the spell + SMARTCAST_AURA_NOT_PRESENT = 0x20, //Only casts the spell if the target does not have an aura from the spell }; // one line in DB is one event diff --git a/src/server/game/AuctionHouse/AuctionHouseMgr.cpp b/src/server/game/AuctionHouse/AuctionHouseMgr.cpp index e7504b4dd..a2e958d68 100644 --- a/src/server/game/AuctionHouse/AuctionHouseMgr.cpp +++ b/src/server/game/AuctionHouse/AuctionHouseMgr.cpp @@ -648,37 +648,37 @@ void AuctionHouseObject::BuildListAuctionItems(WorldPacket& data, Player* player } //this function inserts to WorldPacket auction's data -bool AuctionEntry::BuildAuctionInfo(WorldPacket & data) const +bool AuctionEntry::BuildAuctionInfo(WorldPacket& data) const { - Item* pItem = sAuctionMgr->GetAItem(item_guidlow); - if (!pItem) + Item* item = sAuctionMgr->GetAItem(item_guidlow); + if (!item) { - sLog->outError("auction to item, that doesn't exist !!!!"); + sLog->outError("AuctionEntry::BuildAuctionInfo: Auction %u has a non-existent item: %u", Id, item_guidlow); return false; } data << uint32(Id); - data << uint32(pItem->GetEntry()); + data << uint32(item->GetEntry()); for (uint8 i = 0; i < MAX_INSPECTED_ENCHANTMENT_SLOT; ++i) { - data << uint32(pItem->GetEnchantmentId(EnchantmentSlot(i))); - data << uint32(pItem->GetEnchantmentDuration(EnchantmentSlot(i))); - data << uint32(pItem->GetEnchantmentCharges(EnchantmentSlot(i))); + data << uint32(item->GetEnchantmentId(EnchantmentSlot(i))); + data << uint32(item->GetEnchantmentDuration(EnchantmentSlot(i))); + data << uint32(item->GetEnchantmentCharges(EnchantmentSlot(i))); } - data << int32(pItem->GetItemRandomPropertyId()); //random item property id - data << uint32(pItem->GetItemSuffixFactor()); //SuffixFactor - data << uint32(pItem->GetCount()); //item->count - data << uint32(pItem->GetSpellCharges()); //item->charge FFFFFFF - data << uint32(0); //Unknown - data << uint64(owner); //Auction->owner - data << uint32(startbid); //Auction->startbid (not sure if useful) + data << int32(item->GetItemRandomPropertyId()); // Random item property id + data << uint32(item->GetItemSuffixFactor()); // SuffixFactor + data << uint32(item->GetCount()); // item->count + data << uint32(item->GetSpellCharges()); // item->charge FFFFFFF + data << uint32(0); // Unknown + data << uint64(owner); // Auction->owner + data << uint32(startbid); // Auction->startbid (not sure if useful) data << uint32(bid ? GetAuctionOutBid() : 0); - //minimal outbid - data << uint32(buyout); //auction->buyout - data << uint32((expire_time-time(NULL))*IN_MILLISECONDS);//time left - data << uint64(bidder); //auction->bidder current - data << uint32(bid); //current bid + // Minimal outbid + data << uint32(buyout); // Auction->buyout + data << uint32((expire_time - time(NULL)) * IN_MILLISECONDS); // time left + data << uint64(bidder); // auction->bidder current + data << uint32(bid); // current bid return true; } diff --git a/src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp b/src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp index 3c3d5e165..98bb70466 100755 --- a/src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp +++ b/src/server/game/Battlegrounds/Zones/BattlegroundRV.cpp @@ -102,7 +102,7 @@ void BattlegroundRV::StartingEventOpenDoors() setState(BG_RV_STATE_OPEN_FENCES); setTimer(BG_RV_FIRST_TIMER); - + TogglePillarCollision(true); } @@ -239,11 +239,11 @@ void BattlegroundRV::TogglePillarCollision(bool apply) if (gob->GetGOInfo()->door.startOpen) _state = GO_STATE_ACTIVE; gob->SetGoState(apply ? (GOState)_state : (GOState)(!_state)); - + if (gob->GetGOInfo()->door.startOpen) gob->EnableCollision(!apply); // Forced collision toggle } - + for (BattlegroundPlayerMap::iterator itr = m_Players.begin(); itr != m_Players.end(); ++itr) if (Player* player = ObjectAccessor::FindPlayer(MAKE_NEW_GUID(itr->first, 0, HIGHGUID_PLAYER))) gob->SendUpdateToPlayer(player); diff --git a/src/server/game/CMakeLists.txt b/src/server/game/CMakeLists.txt index fe94c254c..1a853bdf3 100644 --- a/src/server/game/CMakeLists.txt +++ b/src/server/game/CMakeLists.txt @@ -49,6 +49,7 @@ file(GLOB_RECURSE sources_Spells Spells/*.cpp Spells/*.h) file(GLOB_RECURSE sources_Texts Texts/*.cpp Texts/*.h) file(GLOB_RECURSE sources_Tools Tools/*.cpp Tools/*.h) file(GLOB_RECURSE sources_Tickets Tickets/*.cpp Tickets/*.h) +file(GLOB_RECURSE sources_Warden Warden/*.cpp Warden/*.h) file(GLOB_RECURSE sources_Weather Weather/*.cpp Weather/*.h) file(GLOB_RECURSE sources_World World/*.cpp World/*.h) @@ -100,6 +101,7 @@ set(game_STAT_SRCS ${sources_Texts} ${sources_Tools} ${sources_Tickets} + ${sources_Warden} ${sources_Weather} ${sources_World} ) @@ -196,6 +198,8 @@ include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/Texts ${CMAKE_CURRENT_SOURCE_DIR}/Tools ${CMAKE_CURRENT_SOURCE_DIR}/Tickets + ${CMAKE_CURRENT_SOURCE_DIR}/Warden + ${CMAKE_CURRENT_SOURCE_DIR}/Warden/Modules ${CMAKE_CURRENT_SOURCE_DIR}/Weather ${CMAKE_CURRENT_SOURCE_DIR}/World ${CMAKE_SOURCE_DIR}/src/server/scripts/PrecompiledHeaders diff --git a/src/server/game/Chat/Commands/TicketCommands.cpp b/src/server/game/Chat/Commands/TicketCommands.cpp index 138466f96..177899efb 100755 --- a/src/server/game/Chat/Commands/TicketCommands.cpp +++ b/src/server/game/Chat/Commands/TicketCommands.cpp @@ -257,7 +257,7 @@ bool ChatHandler::HandleGMTicketUnAssignCommand(const char* args) ticket->SaveToDB(trans); sTicketMgr->UpdateLastChange(); - std::string msg = ticket->FormatMessageString(*this, NULL, ticket->GetAssignedToName().c_str(), + std::string msg = ticket->FormatMessageString(*this, NULL, ticket->GetAssignedToName().c_str(), m_session ? m_session->GetPlayer()->GetName() : "Console", NULL); SendGlobalGMSysMessage(msg.c_str()); return true; diff --git a/src/server/game/Conditions/ConditionMgr.cpp b/src/server/game/Conditions/ConditionMgr.cpp index bcdc6c265..550814ccf 100755 --- a/src/server/game/Conditions/ConditionMgr.cpp +++ b/src/server/game/Conditions/ConditionMgr.cpp @@ -40,7 +40,6 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo) return false; } bool condMeets = false; - bool sendErrorMsg = false; switch (ConditionType) { case CONDITION_NONE: @@ -49,15 +48,7 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo) case CONDITION_AURA: { if (Unit* unit = object->ToUnit()) - { - if (!ConditionValue3) - condMeets = unit->HasAuraEffect(ConditionValue1, ConditionValue2); - else if (Player* player = unit->ToPlayer()) - { - if (Unit* target = player->GetSelectedUnit()) - condMeets = target->HasAuraEffect(ConditionValue1, ConditionValue2); - } - } + condMeets = unit->HasAuraEffect(ConditionValue1, ConditionValue2); break; } case CONDITION_ITEM: @@ -165,49 +156,12 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo) case CONDITION_SPELL_SCRIPT_TARGET: condMeets = true;//spell target condition is handled in spellsystem, here it is always true break; - case CONDITION_CREATURE_TARGET: - { - if (Player* player = object->ToPlayer()) - { - Unit* target = player->GetSelectedUnit(); - if (target) - if (Creature* cTarget = target->ToCreature()) - if (cTarget->GetEntry() == ConditionValue1) - condMeets = true; - } - break; - } - case CONDITION_TARGET_HEALTH_BELOW_PCT: - { - if (Player* player = object->ToPlayer()) - { - Unit* target = player->GetSelectedUnit(); - if (target) - condMeets = !target->HealthAbovePct(ConditionValue1); - break; - } - } - case CONDITION_TARGET_RANGE: - { - if (Player* player = object->ToPlayer()) - { - if (Unit* target = player->GetSelectedUnit()) - if (player->GetDistance(target) >= ConditionValue1 && (!ConditionValue2 || player->GetDistance(target) <= ConditionValue2)) - condMeets = true; - } - break; - } case CONDITION_MAPID: condMeets = object->GetMapId() == ConditionValue1; break; case CONDITION_AREAID: condMeets = object->GetAreaId() == ConditionValue1; break; - case CONDITION_ITEM_TARGET: - { - condMeets = true; //handled in Item::IsTargetValidForItemUse - break; - } case CONDITION_SPELL: { if (Player* player = object->ToPlayer()) @@ -239,7 +193,7 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo) case CONDITION_OBJECT_ENTRY: { if (object->GetTypeId() == ConditionValue1) - condMeets = (!ConditionValue2) || (object->GetEntry() == ConditionValue2); + condMeets = (!ConditionValue2) || (object->GetEntry() == ConditionValue2); break; } case CONDITION_TYPE_MASK: @@ -343,9 +297,13 @@ uint32 Condition::GetMaxAvailableConditionTargets() switch(SourceType) { case CONDITION_SOURCE_TYPE_SPELL: + case CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE: + case CONDITION_SOURCE_TYPE_VEHICLE_SPELL: + case CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT: + case CONDITION_SOURCE_TYPE_GOSSIP_MENU: + case CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION: + case CONDITION_SOURCE_TYPE_SMART_EVENT: return 2; - case CONDITION_SOURCE_TYPE_SMART_EVENT: - return 2; default: return 1; } @@ -418,6 +376,12 @@ bool ConditionMgr::IsObjectMeetToConditions(WorldObject* object, ConditionList c return IsObjectMeetToConditions(srcInfo, conditions); } +bool ConditionMgr::IsObjectMeetToConditions(WorldObject* object1, WorldObject* object2, ConditionList const& conditions) +{ + ConditionSourceInfo srcInfo = ConditionSourceInfo(object1, object2); + return IsObjectMeetToConditions(srcInfo, conditions); +} + bool ConditionMgr::IsObjectMeetToConditions(ConditionSourceInfo& sourceInfo, ConditionList const& conditions) { if (conditions.empty()) @@ -446,17 +410,34 @@ ConditionList ConditionMgr::GetConditionsForNotGroupedEntry(ConditionSourceType return spellCond; } -ConditionList ConditionMgr::GetConditionsForVehicleSpell(uint32 creatureID, uint32 spellID) + +ConditionList ConditionMgr::GetConditionsForSpellClickEvent(uint32 creatureId, uint32 spellId) { ConditionList cond; - VehicleSpellConditionContainer::const_iterator itr = VehicleSpellConditionStore.find(creatureID); - if (itr != VehicleSpellConditionStore.end()) + CreatureSpellConditionContainer::const_iterator itr = SpellClickEventConditionStore.find(creatureId); + if (itr != SpellClickEventConditionStore.end()) { - ConditionTypeContainer::const_iterator i = (*itr).second.find(spellID); + ConditionTypeContainer::const_iterator i = (*itr).second.find(spellId); if (i != (*itr).second.end()) { cond = (*i).second; - sLog->outDebug(LOG_FILTER_CONDITIONSYS, "GetConditionsForVehicleSpell: found conditions for Vehicle entry %u spell %u", creatureID, spellID); + sLog->outDebug(LOG_FILTER_CONDITIONSYS, "GetConditionsForSpellClickEvent: found conditions for Vehicle entry %u spell %u", creatureId, spellId); + } + } + return cond; +} + +ConditionList ConditionMgr::GetConditionsForVehicleSpell(uint32 creatureId, uint32 spellId) +{ + ConditionList cond; + CreatureSpellConditionContainer::const_iterator itr = VehicleSpellConditionStore.find(creatureId); + if (itr != VehicleSpellConditionStore.end()) + { + ConditionTypeContainer::const_iterator i = (*itr).second.find(spellId); + if (i != (*itr).second.end()) + { + cond = (*i).second; + sLog->outDebug(LOG_FILTER_CONDITIONSYS, "GetConditionsForVehicleSpell: found conditions for Vehicle entry %u spell %u", creatureId, spellId); } } return cond; @@ -543,6 +524,9 @@ void ConditionMgr::LoadConditions(bool isReload) if (iConditionTypeOrReference >= 0) cond->ConditionType = ConditionTypes(iConditionTypeOrReference); + if (iSourceTypeOrReferenceId >= 0) + cond->SourceType = ConditionSourceType(iSourceTypeOrReferenceId); + if (iConditionTypeOrReference < 0)//it has a reference { if (iConditionTypeOrReference == iSourceTypeOrReferenceId)//self referencing, skip @@ -591,8 +575,6 @@ void ConditionMgr::LoadConditions(bool isReload) continue; }//end of reference templates - cond->SourceType = ConditionSourceType(iSourceTypeOrReferenceId); - //if not a reference and SourceType is invalid, skip if (iConditionTypeOrReference >= 0 && !isSourceTypeValid(cond)) { @@ -758,7 +740,7 @@ bool ConditionMgr::addToGossipMenus(Condition* cond) { for (GossipMenusContainer::iterator itr = pMenuBounds.first; itr != pMenuBounds.second; ++itr) { - if ((*itr).second.entry == cond->SourceGroup && (*itr).second.text_id == cond->SourceEntry) + if ((*itr).second.entry == cond->SourceGroup && (*itr).second.text_id == uint32(cond->SourceEntry)) { (*itr).second.conditions.push_back(cond); return true; @@ -777,7 +759,7 @@ bool ConditionMgr::addToGossipMenuItems(Condition* cond) { for (GossipMenuItemsContainer::iterator itr = pMenuItemBounds.first; itr != pMenuItemBounds.second; ++itr) { - if ((*itr).second.MenuId == cond->SourceGroup && (*itr).second.OptionIndex == cond->SourceEntry) + if ((*itr).second.MenuId == cond->SourceGroup && (*itr).second.OptionIndex == uint32(cond->SourceEntry)) { (*itr).second.Conditions.push_back(cond); return true; @@ -1082,50 +1064,6 @@ bool ConditionMgr::isSourceTypeValid(Condition* cond) } break; } - case CONDITION_SOURCE_TYPE_ITEM_REQUIRED_TARGET: - { - if (cond->ConditionType != CONDITION_ITEM_TARGET) - { - sLog->outErrorDb("SourceEntry %u in `condition` table, has ConditionType %u. Only CONDITION_ITEM_TARGET(24) is valid for CONDITION_SOURCE_TYPE_ITEM_REQUIRED_TARGET(18), ignoring.", cond->SourceEntry, uint32(cond->ConditionType)); - return false; - } - - ItemTemplate const* pItemProto = sObjectMgr->GetItemTemplate(cond->SourceEntry); - if (!pItemProto) - { - sLog->outErrorDb("SourceEntry %u in `condition` table, does not exist in `item_tamplate`, ignoring.", cond->SourceEntry); - return false; - } - - bool bIsItemSpellValid = false; - for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i) - { - if (SpellInfo const* pSpellInfo = sSpellMgr->GetSpellInfo(pItemProto->Spells[i].SpellId)) - { - if (pItemProto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_USE || - pItemProto->Spells[i].SpellTrigger == ITEM_SPELLTRIGGER_ON_NO_DELAY_USE) - { - ConditionList conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_SPELL_SCRIPT_TARGET, pSpellInfo->Id);//script loading is done before item target loading - if (!conditions.empty()) - break; - - if (pSpellInfo->NeedsExplicitUnitTarget()) - { - bIsItemSpellValid = true; - break; - } - } - } - } - - if (!bIsItemSpellValid) - { - sLog->outErrorDb("Conditions: CONDITION_SOURCE_TYPE_ITEM_REQUIRED_TARGET for item %u, which either doesn't have item spelltrigger or its spells don't allow caster to select a unit target" - ", or the spells are already listed in CONDITION_SOURCE_TYPE_SPELL_SCRIPT_TARGET conditions.", cond->SourceEntry); - break; - } - break; - } case CONDITION_SOURCE_TYPE_QUEST_ACCEPT: if (!sObjectMgr->GetQuestTemplate(cond->SourceEntry)) { @@ -1147,6 +1085,19 @@ bool ConditionMgr::isSourceTypeValid(Condition* cond) return false; } + if (!sSpellMgr->GetSpellInfo(cond->SourceEntry)) + { + sLog->outErrorDb("SourceEntry %u in `condition` table, does not exist in `spell.dbc`, ignoring.", cond->SourceEntry); + return false; + } + break; + case CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT: + if (!sObjectMgr->GetCreatureTemplate(cond->SourceGroup)) + { + sLog->outErrorDb("SourceEntry %u in `condition` table, does not exist in `creature_template`, ignoring.", cond->SourceGroup); + return false; + } + if (!sSpellMgr->GetSpellInfo(cond->SourceEntry)) { sLog->outErrorDb("SourceEntry %u in `condition` table, does not exist in `spell.dbc`, ignoring.", cond->SourceEntry); @@ -1187,11 +1138,13 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) return false; } - if (cond->ConditionValue2 > 2) + if (cond->ConditionValue2 > EFFECT_2) { sLog->outErrorDb("Aura condition has non existing effect index (%u) (must be 0..2), skipped", cond->ConditionValue2); return false; } + if (cond->ConditionValue3) + sLog->outErrorDb("Aura condition has useless data in value3 (%u)!", cond->ConditionValue3); break; } case CONDITION_ITEM: @@ -1405,45 +1358,6 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) } break; } - case CONDITION_CREATURE_TARGET: - { - if (!cond->ConditionValue1 && !sObjectMgr->GetCreatureTemplate(cond->ConditionValue1)) - { - sLog->outErrorDb("CreatureTarget condition has non existing creature template entry (%u) as target, skipped", cond->ConditionValue1); - return false; - } - - if (cond->ConditionValue2) - sLog->outErrorDb("CreatureTarget condition has useless data in value2 (%u)!", cond->ConditionValue2); - if (cond->ConditionValue3) - sLog->outErrorDb("CreatureTarget condition has useless data in value3 (%u)!", cond->ConditionValue3); - break; - } - case CONDITION_TARGET_HEALTH_BELOW_PCT: - { - if (cond->ConditionValue1 > 100) - { - sLog->outErrorDb("TargetHealthBelowPct condition has invalid data in value1 (%u), skipped", cond->ConditionValue1); - return false; - } - - if (cond->ConditionValue2) - sLog->outErrorDb("TargetHealthBelowPct condition has useless data in value2 (%u)!", cond->ConditionValue2); - if (cond->ConditionValue3) - sLog->outErrorDb("TargetHealthBelowPct condition has useless data in value3 (%u)!", cond->ConditionValue3); - break; - } - case CONDITION_TARGET_RANGE: - { - if (cond->ConditionValue2 && cond->ConditionValue2 < cond->ConditionValue1)//maxDist can be 0 for infinit max range - { - sLog->outErrorDb("TargetRange condition has max distance closer then min distance, skipped"); - return false; - } - if (cond->ConditionValue3) - sLog->outErrorDb("TargetRange condition has useless data in value3 (%u)!", cond->ConditionValue3); - break; - } case CONDITION_MAPID: { MapEntry const* me = sMapStore.LookupEntry(cond->ConditionValue1); @@ -1459,24 +1373,6 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) sLog->outErrorDb("Map condition has useless data in value3 (%u)!", cond->ConditionValue3); break; } - case CONDITION_ITEM_TARGET: - { - if (!cond->ConditionValue1 || cond->ConditionValue1 > MAX_ITEM_REQ_TARGET_TYPE) - { - sLog->outErrorDb("ItemTarget condition has incorrect target type (%u), skipped", cond->ConditionValue1); - return false; - } - - if (!cond->ConditionValue2 && !sObjectMgr->GetCreatureTemplate(cond->ConditionValue2)) - { - sLog->outErrorDb("ItemTarget condition has non existing creature template entry (%u) as target, skipped", cond->ConditionValue2); - return false; - } - - if (cond->ConditionValue3) - sLog->outErrorDb("ItemTarget condition has useless data in value3 (%u)!", cond->ConditionValue3); - break; - } case CONDITION_SPELL: { if (!sSpellMgr->GetSpellInfo(cond->ConditionValue1)) @@ -1568,7 +1464,7 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) return false; } if (cond->ConditionValue3) - sLog->outErrorDb("ObjectEntry condition has useless data in value3 (%u)!", cond->ConditionValue3); + sLog->outErrorDb("ObjectEntry condition has useless data in value3 (%u)!", cond->ConditionValue3); break; } case CONDITION_TYPE_MASK: @@ -1702,6 +1598,18 @@ bool ConditionMgr::isConditionTypeValid(Condition* cond) sLog->outErrorDb("Phasemask condition has useless data in value3 (%u)!", cond->ConditionValue3); break; } + case CONDITION_UNUSED_19: + sLog->outErrorDb("Found ConditionTypeOrReference = CONDITION_UNUSED_19 in `conditions` table - ignoring"); + return false; + case CONDITION_UNUSED_20: + sLog->outErrorDb("Found ConditionTypeOrReference = CONDITION_UNUSED_20 in `conditions` table - ignoring"); + return false; + case CONDITION_UNUSED_21: + sLog->outErrorDb("Found ConditionTypeOrReference = CONDITION_UNUSED_21 in `conditions` table - ignoring"); + return false; + case CONDITION_UNUSED_24: + sLog->outErrorDb("Found ConditionTypeOrReference = CONDITION_UNUSED_24 in `conditions` table - ignoring"); + return false; default: break; } @@ -1732,7 +1640,7 @@ void ConditionMgr::Clean() ConditionStore.clear(); - for (VehicleSpellConditionContainer::iterator itr = VehicleSpellConditionStore.begin(); itr != VehicleSpellConditionStore.end(); ++itr) + for (CreatureSpellConditionContainer::iterator itr = VehicleSpellConditionStore.begin(); itr != VehicleSpellConditionStore.end(); ++itr) { for (ConditionTypeContainer::iterator it = itr->second.begin(); it != itr->second.end(); ++it) { diff --git a/src/server/game/Conditions/ConditionMgr.h b/src/server/game/Conditions/ConditionMgr.h index dc204ccd0..9911aa2a9 100755 --- a/src/server/game/Conditions/ConditionMgr.h +++ b/src/server/game/Conditions/ConditionMgr.h @@ -49,12 +49,12 @@ enum ConditionTypes CONDITION_RACE = 16, // race 0 0 true if player's race is equal to race CONDITION_ACHIEVEMENT = 17, // achievement_id 0 0 true if achievement is complete CONDITION_SPELL_SCRIPT_TARGET = 18, // SpellScriptTargetType, TargetEntry, 0 - CONDITION_CREATURE_TARGET = 19, // creature entry 0 0 true if current target is creature with value1 entry - CONDITION_TARGET_HEALTH_BELOW_PCT = 20, // 0-100 0 0 true if target's health is below value1 percent, false if over or no target - CONDITION_TARGET_RANGE = 21, // minDistance maxDist 0 true if target is closer then minDist and further then maxDist or if max is 0 then max dist is infinit + CONDITION_UNUSED_19 = 19, // + CONDITION_UNUSED_20 = 20, // + CONDITION_UNUSED_21 = 21, // CONDITION_MAPID = 22, // map_id 0 0 true if in map_id CONDITION_AREAID = 23, // area_id 0 0 true if in area_id - CONDITION_ITEM_TARGET = 24, // ItemRequiredTargetType, TargetEntry, 0 + CONDITION_UNUSED_24 = 24, // CONDITION_SPELL = 25, // spell_id 0 0 true if player has learned spell CONDITION_PHASEMASK = 26, // phasemask 0 0 true if object is in phasemask CONDITION_LEVEL = 27, // level ComparisonType 0 true if unit's level is equal to param1 (param2 can modify the statement) @@ -92,7 +92,7 @@ enum ConditionSourceType CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION = 15, CONDITION_SOURCE_TYPE_CREATURE_TEMPLATE_VEHICLE = 16, CONDITION_SOURCE_TYPE_SPELL = 17, - CONDITION_SOURCE_TYPE_ITEM_REQUIRED_TARGET = 18, + CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT = 18, CONDITION_SOURCE_TYPE_QUEST_ACCEPT = 19, CONDITION_SOURCE_TYPE_QUEST_SHOW_MARK = 20, CONDITION_SOURCE_TYPE_VEHICLE_SPELL = 21, @@ -167,7 +167,7 @@ struct Condition ConditionValue2 = 0; ConditionValue3 = 0; ReferenceId = 0; - ErrorTextId = 0; + ErrorTextId = 0; ScriptId = 0; NegativeCondition = false; } @@ -180,7 +180,7 @@ struct Condition typedef std::list ConditionList; typedef std::map ConditionTypeContainer; typedef std::map ConditionContainer; -typedef std::map VehicleSpellConditionContainer; +typedef std::map CreatureSpellConditionContainer; typedef std::map, ConditionTypeContainer> SmartEventConditionContainer; typedef std::map ConditionReferenceContainer;//only used for references @@ -199,10 +199,12 @@ class ConditionMgr ConditionList GetConditionReferences(uint32 refId); bool IsObjectMeetToConditions(WorldObject* object, ConditionList const& conditions); + bool IsObjectMeetToConditions(WorldObject* object1, WorldObject* object2, ConditionList const& conditions); bool IsObjectMeetToConditions(ConditionSourceInfo& sourceInfo, ConditionList const& conditions); ConditionList GetConditionsForNotGroupedEntry(ConditionSourceType sourceType, uint32 entry); + ConditionList GetConditionsForSpellClickEvent(uint32 creatureId, uint32 spellId); ConditionList GetConditionsForSmartEvent(int32 entryOrGuid, uint32 eventId, uint32 sourceType); - ConditionList GetConditionsForVehicleSpell(uint32 creatureID, uint32 spellID); + ConditionList GetConditionsForVehicleSpell(uint32 creatureId, uint32 spellId); private: bool isSourceTypeValid(Condition* cond); @@ -227,6 +229,7 @@ class ConditionMgr sourceType == CONDITION_SOURCE_TYPE_SPELL_LOOT_TEMPLATE || sourceType == CONDITION_SOURCE_TYPE_GOSSIP_MENU || sourceType == CONDITION_SOURCE_TYPE_GOSSIP_MENU_OPTION || + sourceType == CONDITION_SOURCE_TYPE_SPELL_CLICK_EVENT || sourceType == CONDITION_SOURCE_TYPE_VEHICLE_SPELL || sourceType == CONDITION_SOURCE_TYPE_SMART_EVENT); } @@ -236,7 +239,8 @@ class ConditionMgr ConditionContainer ConditionStore; ConditionReferenceContainer ConditionReferenceStore; - VehicleSpellConditionContainer VehicleSpellConditionStore; + CreatureSpellConditionContainer VehicleSpellConditionStore; + CreatureSpellConditionContainer SpellClickEventConditionStore; SmartEventConditionContainer SmartEventConditionStore; }; @@ -254,10 +258,11 @@ template bool CompareValues(ComparisionType type, T val1, T val2) return val1 >= val2; case COMP_TYPE_LOW_EQ: return val1 <= val2; + default: + // incorrect parameter + ASSERT(false); + return false; } - // incorrect parameter - ASSERT(false); - return false; } #define sConditionMgr ACE_Singleton::instance() diff --git a/src/server/game/DungeonFinding/LFGMgr.cpp b/src/server/game/DungeonFinding/LFGMgr.cpp index cccb780e4..e6039880b 100755 --- a/src/server/game/DungeonFinding/LFGMgr.cpp +++ b/src/server/game/DungeonFinding/LFGMgr.cpp @@ -83,12 +83,12 @@ void LFGMgr::_LoadFromDB(Field* fields, uint64 guid) uint32 dungeon = fields[16].GetUInt32(); uint8 state = fields[17].GetUInt8(); - + if (!dungeon || !state) return; SetDungeon(guid, dungeon); - + switch (state) { case LFG_STATE_DUNGEON: @@ -104,19 +104,19 @@ void LFGMgr::_SaveToDB(uint64 guid, uint32 db_guid) { if (!IS_GROUP(guid)) return; - + PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_LFG_DATA); stmt->setUInt32(0, db_guid); CharacterDatabase.Execute(stmt); - + stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_LFG_DATA); stmt->setUInt32(0, db_guid); - + stmt->setUInt32(1, GetDungeon(guid)); stmt->setUInt32(2, GetState(guid)); - + CharacterDatabase.Execute(stmt); } @@ -999,7 +999,7 @@ bool LFGMgr::CheckCompatibility(LfgGuidList check, LfgProposal*& pProposal) LfgQueueInfo* queue = itQueue->second; if (!queue) continue; - + for (LfgRolesMap::const_iterator itPlayer = queue->roles.begin(); itPlayer != queue->roles.end(); ++itPlayer) { if (*itPlayers == ObjectAccessor::FindPlayer(itPlayer->first)) diff --git a/src/server/game/Entities/Creature/Creature.cpp b/src/server/game/Entities/Creature/Creature.cpp index cbd092211..3dfa1cece 100755 --- a/src/server/game/Entities/Creature/Creature.cpp +++ b/src/server/game/Entities/Creature/Creature.cpp @@ -141,11 +141,11 @@ bool ForcedDespawnDelayEvent::Execute(uint64 /*e_time*/, uint32 /*p_time*/) Creature::Creature(bool isWorldObject): Unit(isWorldObject), MapCreature(), lootForPickPocketed(false), lootForBody(false), m_groupLootTimer(0), lootingGroupLowGUID(0), -m_PlayerDamageReq(0), m_lootMoney(0), m_lootRecipient(0), m_lootRecipientGroup(0), m_corpseRemoveTime(0), m_respawnTime(0), +m_PlayerDamageReq(0), m_lootRecipient(0), m_lootRecipientGroup(0), m_corpseRemoveTime(0), m_respawnTime(0), m_respawnDelay(300), m_corpseDelay(60), m_respawnradius(0.0f), m_reactState(REACT_AGGRESSIVE), m_defaultMovementType(IDLE_MOTION_TYPE), m_DBTableGuid(0), m_equipmentId(0), m_AlreadyCallAssistance(false), m_AlreadySearchedAssistance(false), m_regenHealth(true), m_AI_locked(false), m_meleeDamageSchoolMask(SPELL_SCHOOL_MASK_NORMAL), -m_creatureInfo(NULL), m_creatureData(NULL), m_formation(NULL), m_path_id(0) +m_creatureInfo(NULL), m_creatureData(NULL), m_path_id(0), m_formation(NULL) { m_regenTimer = CREATURE_REGEN_INTERVAL; m_valuesCount = UNIT_END; @@ -1415,7 +1415,7 @@ bool Creature::canStartAttack(Unit const* who, bool force) const if (HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC)) return false; - + // Do not attack non-combat pets if (who->GetTypeId() == TYPEID_UNIT && who->GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET) return false; diff --git a/src/server/game/Entities/Creature/Creature.h b/src/server/game/Entities/Creature/Creature.h index 1e3603428..bfe186329 100755 --- a/src/server/game/Entities/Creature/Creature.h +++ b/src/server/game/Entities/Creature/Creature.h @@ -721,7 +721,6 @@ class Creature : public Unit, public GridObject, public MapCreature static float _GetHealthMod(int32 Rank); - uint32 m_lootMoney; uint64 m_lootRecipient; uint32 m_lootRecipientGroup; diff --git a/src/server/game/Entities/GameObject/GameObject.cpp b/src/server/game/Entities/GameObject/GameObject.cpp index 76d035a6d..aacf15e84 100755 --- a/src/server/game/Entities/GameObject/GameObject.cpp +++ b/src/server/game/Entities/GameObject/GameObject.cpp @@ -33,7 +33,7 @@ #include "GameObjectModel.h" #include "DynamicTree.h" -GameObject::GameObject() : WorldObject(false), m_goValue(new GameObjectValue), m_AI(NULL), m_model(NULL) +GameObject::GameObject() : WorldObject(false), m_model(NULL), m_goValue(new GameObjectValue), m_AI(NULL) { m_objectType |= TYPEMASK_GAMEOBJECT; m_objectTypeId = TYPEID_GAMEOBJECT; diff --git a/src/server/game/Entities/GameObject/GameObject.h b/src/server/game/Entities/GameObject/GameObject.h index 09e0898d6..dec63464c 100755 --- a/src/server/game/Entities/GameObject/GameObject.h +++ b/src/server/game/Entities/GameObject/GameObject.h @@ -711,7 +711,7 @@ class GameObject : public WorldObject, public GridObject uint8 GetGoAnimProgress() const { return GetByteValue(GAMEOBJECT_BYTES_1, 3); } void SetGoAnimProgress(uint8 animprogress) { SetByteValue(GAMEOBJECT_BYTES_1, 3, animprogress); } static void SetGoArtKit(uint8 artkit, GameObject* go, uint32 lowguid = 0); - + void SetPhaseMask(uint32 newPhaseMask, bool update); void EnableCollision(bool enable); @@ -796,7 +796,7 @@ class GameObject : public WorldObject, public GridObject std::string GetAIName() const; void SetDisplayId(uint32 displayid); - + GameObjectModel * m_model; protected: bool AIM_Initialize(); diff --git a/src/server/game/Entities/Item/Item.cpp b/src/server/game/Entities/Item/Item.cpp index f303f7bf8..70b81593b 100755 --- a/src/server/game/Entities/Item/Item.cpp +++ b/src/server/game/Entities/Item/Item.cpp @@ -870,24 +870,6 @@ bool Item::IsFitToSpellRequirements(SpellInfo const* spellInfo) const return true; } -bool Item::IsTargetValidForItemUse(Unit* pUnitTarget) -{ - ConditionList conditions = sConditionMgr->GetConditionsForNotGroupedEntry(CONDITION_SOURCE_TYPE_ITEM_REQUIRED_TARGET, GetTemplate()->ItemId); - if (conditions.empty()) - return true; - - if (!pUnitTarget) - return false; - - for (ConditionList::const_iterator itr = conditions.begin(); itr != conditions.end(); ++itr) - { - ItemRequiredTarget irt(ItemRequiredTargetType((*itr)->ConditionValue1), (*itr)->ConditionValue2); - if (irt.IsFitToRequirements(pUnitTarget)) - return true; - } - return false; -} - void Item::SetEnchantment(EnchantmentSlot slot, uint32 id, uint32 duration, uint32 charges) { // Better lost small time at check in comparison lost time at item save to DB. @@ -1092,25 +1074,6 @@ bool Item::IsBindedNotWith(Player const* player) const return true; } -bool ItemRequiredTarget::IsFitToRequirements(Unit* pUnitTarget) const -{ - if (pUnitTarget->GetTypeId() != TYPEID_UNIT) - return false; - - if (pUnitTarget->GetEntry() != m_uiTargetEntry) - return false; - - switch (m_uiType) - { - case ITEM_TARGET_TYPE_CREATURE: - return pUnitTarget->isAlive(); - case ITEM_TARGET_TYPE_DEAD: - return !pUnitTarget->isAlive(); - default: - return false; - } -} - void Item::BuildUpdate(UpdateDataMapType& data_map) { if (Player* owner = GetOwner()) diff --git a/src/server/game/Entities/Item/Item.h b/src/server/game/Entities/Item/Item.h index 0960a3e55..3a197a834 100755 --- a/src/server/game/Entities/Item/Item.h +++ b/src/server/game/Entities/Item/Item.h @@ -201,26 +201,8 @@ enum ItemUpdateState ITEM_REMOVED = 3 }; -enum ItemRequiredTargetType -{ - ITEM_TARGET_TYPE_CREATURE = 1, - ITEM_TARGET_TYPE_DEAD = 2 -}; - -#define MAX_ITEM_REQ_TARGET_TYPE 2 - #define MAX_ITEM_SPELLS 5 -struct ItemRequiredTarget -{ - ItemRequiredTarget(ItemRequiredTargetType uiType, uint32 uiTargetEntry) : m_uiType(uiType), m_uiTargetEntry(uiTargetEntry) {} - ItemRequiredTargetType m_uiType; - uint32 m_uiTargetEntry; - - // helpers - bool IsFitToRequirements(Unit* pUnitTarget) const; -}; - bool ItemCanGoIntoBag(ItemTemplate const* proto, ItemTemplate const* pBagProto); class Item : public Object @@ -268,7 +250,6 @@ class Item : public Object uint32 GetEnchantRequiredLevel() const; bool IsFitToSpellRequirements(SpellInfo const* spellInfo) const; - bool IsTargetValidForItemUse(Unit* pUnitTarget); bool IsLimitedToAnotherMapOrZone(uint32 cur_mapId, uint32 cur_zoneId) const; bool GemsFitSockets() const; diff --git a/src/server/game/Entities/Player/Player.cpp b/src/server/game/Entities/Player/Player.cpp index cc26a9c12..5016f0f06 100755 --- a/src/server/game/Entities/Player/Player.cpp +++ b/src/server/game/Entities/Player/Player.cpp @@ -435,9 +435,9 @@ void TradeData::SetAccepted(bool state, bool crosssend /*= false*/) // 5. Credit instance encounter. KillRewarder::KillRewarder(Player* killer, Unit* victim, bool isBattleGround) : // 1. Initialize internal variables to default values. - _killer(killer), _victim(victim), _isBattleGround(isBattleGround), - _isPvP(false), _group(killer->GetGroup()), _groupRate(1.0f), - _maxLevel(0), _maxNotGrayMember(NULL), _count(0), _sumLevel(0), _isFullXP(false), _xp(0) + _killer(killer), _victim(victim), _group(killer->GetGroup()), + _groupRate(1.0f), _maxNotGrayMember(NULL), _count(0), _sumLevel(0), _xp(0), + _isFullXP(false), _maxLevel(0), _isBattleGround(isBattleGround), _isPvP(false) { // mark the credit as pvp if victim is player if (victim->GetTypeId() == TYPEID_PLAYER) @@ -11839,7 +11839,7 @@ InventoryResult Player::CanRollForItemInLFG(ItemTemplate const* proto, WorldObje Map const* map = lootedObject->GetMap(); if (uint32 dungeonId = sLFGMgr->GetDungeon(GetGroup()->GetGUID(), true)) if (LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(dungeonId)) - if (dungeon->map == map->GetId() && dungeon->difficulty == map->GetDifficulty()) + if (uint32(dungeon->map) == map->GetId() && dungeon->difficulty == map->GetDifficulty()) lootedObjectInDungeon = true; if (!lootedObjectInDungeon) @@ -12033,7 +12033,6 @@ Item* Player::StoreItem(ItemPosCountVec const& dest, Item* pItem, bool update) return NULL; Item* lastItem = pItem; - uint32 entry = pItem->GetEntry(); for (ItemPosCountVec::const_iterator itr = dest.begin(); itr != dest.end();) { uint16 pos = itr->pos; @@ -14098,7 +14097,7 @@ void Player::PrepareGossipMenu(WorldObject* source, uint32 menuId /*= 0*/, bool for (GossipMenuItemsContainer::const_iterator itr = menuItemBounds.first; itr != menuItemBounds.second; ++itr) { bool canTalk = true; - if (!sConditionMgr->IsObjectMeetToConditions(this, itr->second.Conditions)) + if (!sConditionMgr->IsObjectMeetToConditions(this, source, itr->second.Conditions)) continue; if (source->GetTypeId() == TYPEID_UNIT) @@ -14242,7 +14241,7 @@ void Player::SendPreparedGossip(WorldObject* source) uint32 textId = GetGossipTextId(source); if (uint32 menuId = PlayerTalkClass->GetGossipMenu().GetMenuId()) - textId = GetGossipTextId(menuId); + textId = GetGossipTextId(menuId, source); PlayerTalkClass->SendGossipMenu(textId, source->GetGUID()); } @@ -14387,10 +14386,10 @@ uint32 Player::GetGossipTextId(WorldObject* source) if (!source) return DEFAULT_GOSSIP_MESSAGE; - return GetGossipTextId(GetDefaultGossipMenuForSource(source)); + return GetGossipTextId(GetDefaultGossipMenuForSource(source), source); } -uint32 Player::GetGossipTextId(uint32 menuId) +uint32 Player::GetGossipTextId(uint32 menuId, WorldObject* source) { uint32 textId = DEFAULT_GOSSIP_MESSAGE; @@ -14400,8 +14399,10 @@ uint32 Player::GetGossipTextId(uint32 menuId) GossipMenusMapBounds menuBounds = sObjectMgr->GetGossipMenusMapBounds(menuId); for (GossipMenusContainer::const_iterator itr = menuBounds.first; itr != menuBounds.second; ++itr) - if (sConditionMgr->IsObjectMeetToConditions(this, itr->second.conditions)) + { + if (sConditionMgr->IsObjectMeetToConditions(this, source, itr->second.conditions)) textId = itr->second.text_id; + } return textId; } @@ -14836,7 +14837,7 @@ void Player::AddQuest(Quest const* quest, Object* questGiver) uint16 log_slot = FindQuestSlot(0); if (log_slot >= MAX_QUEST_LOG_SIZE) // Player does not have any free slot in the quest log - return; + return; uint32 quest_id = quest->GetQuestId(); @@ -19871,7 +19872,7 @@ void Player::VehicleSpellInitialize() } ConditionList conditions = sConditionMgr->GetConditionsForVehicleSpell(veh->GetEntry(), spellId); - if (!sConditionMgr->IsObjectMeetToConditions(this, conditions)) + if (!sConditionMgr->IsObjectMeetToConditions(this, veh, conditions)) { sLog->outDebug(LOG_FILTER_CONDITIONSYS, "VehicleSpellInitialize: conditions not met for Vehicle entry %u spell %u", veh->ToCreature()->GetEntry(), spellId); data << uint16(0) << uint8(0) << uint8(i+8); @@ -20277,9 +20278,7 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc // not let cheating with start flight in time of logout process || while in combat || has type state: stunned || has type state: root if (GetSession()->isLogingOut() || isInCombat() || HasUnitState(UNIT_STATE_STUNNED) || HasUnitState(UNIT_STATE_ROOT)) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIPLAYERBUSY); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIPLAYERBUSY); return false; } @@ -20292,26 +20291,20 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc // not let cheating with start flight mounted if (IsMounted()) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIPLAYERALREADYMOUNTED); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIPLAYERALREADYMOUNTED); return false; } if (IsInDisallowedMountForm()) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIPLAYERSHAPESHIFTED); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIPLAYERSHAPESHIFTED); return false; } // not let cheating with start flight in time of logout process || if casting not finished || while in combat || if not use Spell's with EffectSendTaxi if (IsNonMeleeSpellCasted(false)) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIPLAYERBUSY); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIPLAYERBUSY); return false; } } @@ -20340,9 +20333,7 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc TaxiNodesEntry const* node = sTaxiNodesStore.LookupEntry(sourcenode); if (!node) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXINOSUCHPATH); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXINOSUCHPATH); return false; } @@ -20355,18 +20346,14 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc (node->z - GetPositionZ())*(node->z - GetPositionZ()) > (2*INTERACTION_DISTANCE)*(2*INTERACTION_DISTANCE)*(2*INTERACTION_DISTANCE)) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXITOOFARAWAY); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXITOOFARAWAY); return false; } } // node must have pos if taxi master case (npc != NULL) else if (npc) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIUNSPECIFIEDSERVERERROR); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIUNSPECIFIEDSERVERERROR); return false; } @@ -20429,9 +20416,7 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc // in spell case allow 0 model if ((mount_display_id == 0 && spellid == 0) || sourcepath == 0) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIUNSPECIFIEDSERVERERROR); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXIUNSPECIFIEDSERVERERROR); m_taxi.ClearTaxiDestinations(); return false; } @@ -20443,9 +20428,7 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc if (money < totalcost) { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXINOTENOUGHMONEY); - GetSession()->SendPacket(&data); + GetSession()->SendActivateTaxiReply(ERR_TAXINOTENOUGHMONEY); m_taxi.ClearTaxiDestinations(); return false; } @@ -20467,10 +20450,7 @@ bool Player::ActivateTaxiPathTo(std::vector const& nodes, Creature* npc } else { - WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); - data << uint32(ERR_TAXIOK); - GetSession()->SendPacket(&data); - sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ACTIVATETAXIREPLY"); + GetSession()->SendActivateTaxiReply(ERR_TAXIOK); GetSession()->SendDoFlight(mount_display_id, sourcepath); } return true; @@ -22394,11 +22374,21 @@ void Player::UpdateForQuestWorldObjects() SpellClickInfoMapBounds clickPair = sObjectMgr->GetSpellClickInfoMapBounds(obj->GetEntry()); for (SpellClickInfoContainer::const_iterator _itr = clickPair.first; _itr != clickPair.second; ++_itr) - if (_itr->second.questStart || _itr->second.questEnd) + { + //! This code doesn't look right, but it was logically converted to condition system to do the exact + //! same thing it did before. It definitely needs to be overlooked for intended functionality. + ConditionList conds = sConditionMgr->GetConditionsForSpellClickEvent(obj->GetEntry(), _itr->second.spellId); + bool buildUpdateBlock = false; + for (ConditionList::const_iterator jtr = conds.begin(); jtr != conds.end() && !buildUpdateBlock; ++jtr) + if ((*jtr)->ConditionType == CONDITION_QUESTREWARDED || (*jtr)->ConditionType == CONDITION_QUESTTAKEN) + buildUpdateBlock = true; + + if (buildUpdateBlock) { obj->BuildCreateUpdateBlockForPlayer(&udata, this); break; } + } } } udata.BuildPacket(&packet); @@ -24171,10 +24161,17 @@ bool Player::canSeeSpellClickOn(Creature const* c) const return true; for (SpellClickInfoContainer::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr) - if (itr->second.IsFitToRequirements(this, c)) - return true; + { + if (!itr->second.IsFitToRequirements(this, c)) + return false; - return false; + ConditionList conds = sConditionMgr->GetConditionsForSpellClickEvent(c->GetEntry(), itr->second.spellId); + ConditionSourceInfo info = ConditionSourceInfo(const_cast(this), const_cast(c)); + if (!sConditionMgr->IsObjectMeetToConditions(info, conds)) + return false; + } + + return true; } void Player::BuildPlayerTalentsInfoData(WorldPacket* data) diff --git a/src/server/game/Entities/Player/Player.h b/src/server/game/Entities/Player/Player.h index 3327276ed..762435af7 100755 --- a/src/server/game/Entities/Player/Player.h +++ b/src/server/game/Entities/Player/Player.h @@ -466,23 +466,6 @@ enum PlayerFieldByte2Flags PLAYER_FIELD_BYTE2_INVISIBILITY_GLOW = 0x40 }; -enum ActivateTaxiReplies -{ - ERR_TAXIOK = 0, - ERR_TAXIUNSPECIFIEDSERVERERROR = 1, - ERR_TAXINOSUCHPATH = 2, - ERR_TAXINOTENOUGHMONEY = 3, - ERR_TAXITOOFARAWAY = 4, - ERR_TAXINOVENDORNEARBY = 5, - ERR_TAXINOTVISITED = 6, - ERR_TAXIPLAYERBUSY = 7, - ERR_TAXIPLAYERALREADYMOUNTED = 8, - ERR_TAXIPLAYERSHAPESHIFTED = 9, - ERR_TAXIPLAYERMOVING = 10, - ERR_TAXISAMENODE = 11, - ERR_TAXINOTSTANDING = 12 -}; - enum MirrorTimerType { FATIGUE_TIMER = 0, @@ -1383,7 +1366,7 @@ class Player : public Unit, public GridObject void SendPreparedGossip(WorldObject* source); void OnGossipSelect(WorldObject* source, uint32 gossipListId, uint32 menuId); - uint32 GetGossipTextId(uint32 menuId); + uint32 GetGossipTextId(uint32 menuId, WorldObject* source); uint32 GetGossipTextId(WorldObject* source); static uint32 GetDefaultGossipMenuForSource(WorldObject* source); diff --git a/src/server/game/Entities/Unit/Unit.cpp b/src/server/game/Entities/Unit/Unit.cpp index ab8ab9153..85979cb74 100755 --- a/src/server/game/Entities/Unit/Unit.cpp +++ b/src/server/game/Entities/Unit/Unit.cpp @@ -55,6 +55,7 @@ #include "SpellInfo.h" #include "MoveSplineInit.h" #include "MoveSpline.h" +#include "ConditionMgr.h" #include "BattlefieldMgr.h" #include @@ -146,9 +147,10 @@ _hitMask(hitMask), _spell(spell), _damageInfo(damageInfo), _healInfo(healInfo) #endif Unit::Unit(bool isWorldObject): WorldObject(isWorldObject), m_movedPlayer(NULL), m_lastSanctuaryTime(0), IsAIEnabled(false), NeedChangeAI(false), -m_ControlledByPlayer(false), i_AI(NULL), i_disabledAI(NULL), m_procDeep(0), -m_removedAurasCount(0), i_motionMaster(this), m_ThreatManager(this), m_vehicle(NULL), -m_vehicleKit(NULL), m_unitTypeMask(UNIT_MASK_NONE), m_HostileRefManager(this), movespline(new Movement::MoveSpline()) +m_ControlledByPlayer(false), movespline(new Movement::MoveSpline()), i_AI(NULL), +i_disabledAI(NULL), m_procDeep(0), m_removedAurasCount(0), i_motionMaster(this), +m_ThreatManager(this), m_vehicle(NULL), m_vehicleKit(NULL), m_unitTypeMask(UNIT_MASK_NONE), +m_HostileRefManager(this) { #ifdef _MSC_VER #pragma warning(default:4355) @@ -1883,7 +1885,7 @@ void Unit::AttackerStateUpdate (Unit* victim, WeaponAttackType attType, bool ext else { // attack can be redirected to another target - victim = SelectMagnetTarget(victim); + victim = GetMeleeHitRedirectTarget(victim); CalcDamageInfo damageInfo; CalculateMeleeDamage(victim, 0, &damageInfo, attType); @@ -7010,8 +7012,8 @@ bool Unit::HandleDummyAuraProc(Unit* victim, uint32 damage, AuraEffect* triggere WeaponAttackType attType = WeaponAttackType(player->GetAttackBySlot(castItem->GetSlot())); if ((attType != BASE_ATTACK && attType != OFF_ATTACK) - || attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK - || attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK) + || (attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK) + || (attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK)) return false; // Now compute real proc chance... @@ -7307,8 +7309,8 @@ bool Unit::HandleDummyAuraProc(Unit* victim, uint32 damage, AuraEffect* triggere Player* player = ToPlayer(); WeaponAttackType attType = WeaponAttackType(player->GetAttackBySlot(castItem->GetSlot())); if ((attType != BASE_ATTACK && attType != OFF_ATTACK) - || attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK - || attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK) + || (attType == BASE_ATTACK && procFlag & PROC_FLAG_DONE_OFFHAND_ATTACK) + || (attType == OFF_ATTACK && procFlag & PROC_FLAG_DONE_MAINHAND_ATTACK)) return false; float fire_onhit = float(CalculatePctF(dummySpell->Effects[EFFECT_0]. CalcValue(), 1.0f)); @@ -9767,6 +9769,7 @@ void Unit::SetMinion(Minion *minion, bool apply) { // Send infinity cooldown - client does that automatically but after relog cooldown needs to be set again SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(minion->GetUInt32Value(UNIT_CREATED_BY_SPELL)); + if (spellInfo && (spellInfo->Attributes & SPELL_ATTR0_DISABLED_WHILE_ACTIVE)) ToPlayer()->AddSpellAndCategoryCooldowns(spellInfo, 0, NULL, true); } @@ -9986,44 +9989,43 @@ int32 Unit::DealHeal(Unit* victim, uint32 addhealth) return gain; } -Unit* Unit::SelectMagnetTarget(Unit* victim, SpellInfo const* spellInfo) +Unit* Unit::GetMagicHitRedirectTarget(Unit* victim, SpellInfo const* spellInfo) { - if (!victim) - return NULL; + // Patch 1.2 notes: Spell Reflection no longer reflects abilities + if (spellInfo->Attributes & SPELL_ATTR0_ABILITY || spellInfo->AttributesEx & SPELL_ATTR1_CANT_BE_REDIRECTED || spellInfo->Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY) + return victim; - // Magic case - if (spellInfo && (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_NONE || spellInfo->DmgClass == SPELL_DAMAGE_CLASS_MAGIC)) + Unit::AuraEffectList const& magnetAuras = victim->GetAuraEffectsByType(SPELL_AURA_SPELL_MAGNET); + for (Unit::AuraEffectList::const_iterator itr = magnetAuras.begin(); itr != magnetAuras.end(); ++itr) { - // Patch 1.2 notes: Spell Reflection no longer reflects abilities - if (spellInfo->Attributes & SPELL_ATTR0_ABILITY || spellInfo->AttributesEx & SPELL_ATTR1_CANT_BE_REDIRECTED || spellInfo->Attributes & SPELL_ATTR0_UNAFFECTED_BY_INVULNERABILITY) - return victim; - // I am not sure if this should be redirected. - if (spellInfo->DmgClass == SPELL_DAMAGE_CLASS_NONE) - return victim; + if (Unit* magnet = (*itr)->GetBase()->GetUnitOwner()) + if (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK + && spellInfo->CheckTarget(this, magnet, false) == SPELL_CAST_OK + && _IsValidAttackTarget(magnet, spellInfo) + && IsWithinLOSInMap(magnet)) + { + (*itr)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE); + return magnet; + } + } + return victim; +} - Unit::AuraEffectList const& magnetAuras = victim->GetAuraEffectsByType(SPELL_AURA_SPELL_MAGNET); - for (Unit::AuraEffectList::const_iterator itr = magnetAuras.begin(); itr != magnetAuras.end(); ++itr) - if (Unit* magnet = (*itr)->GetBase()->GetUnitOwner()) - if (magnet->isAlive() && IsWithinLOSInMap(magnet)) +Unit* Unit::GetMeleeHitRedirectTarget(Unit* victim, SpellInfo const* spellInfo) +{ + AuraEffectList const& hitTriggerAuras = victim->GetAuraEffectsByType(SPELL_AURA_ADD_CASTER_HIT_TRIGGER); + for (AuraEffectList::const_iterator i = hitTriggerAuras.begin(); i != hitTriggerAuras.end(); ++i) + { + if (Unit* magnet = (*i)->GetBase()->GetCaster()) + if (_IsValidAttackTarget(magnet, spellInfo) && magnet->IsWithinLOSInMap(this) + && (!spellInfo || (spellInfo->CheckExplicitTarget(this, magnet) == SPELL_CAST_OK + && spellInfo->CheckTarget(this, magnet, false) == SPELL_CAST_OK))) + if (roll_chance_i((*i)->GetAmount())) { - (*itr)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE); + (*i)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE); return magnet; } } - // Melee && ranged case - else - { - AuraEffectList const& hitTriggerAuras = victim->GetAuraEffectsByType(SPELL_AURA_ADD_CASTER_HIT_TRIGGER); - for (AuraEffectList::const_iterator i = hitTriggerAuras.begin(); i != hitTriggerAuras.end(); ++i) - if (Unit* magnet = (*i)->GetBase()->GetCaster()) - if (magnet->isAlive() && magnet->IsWithinLOSInMap(this)) - if (roll_chance_i((*i)->GetAmount())) - { - (*i)->GetBase()->DropCharge(AURA_REMOVE_BY_EXPIRE); - return magnet; - } - } - return victim; } @@ -12163,7 +12165,7 @@ bool Unit::_IsValidAttackTarget(Unit const* target, SpellInfo const* bySpell) co if (FactionTemplateEntry const* factionTemplate = creature->getFactionTemplateEntry()) if (FactionEntry const* factionEntry = sFactionStore.LookupEntry(factionTemplate->faction)) if (FactionState const* repState = player->GetReputationMgr().GetState(factionEntry)) - if (repState->Flags & FACTION_FLAG_PEACE_FORCED) + if (!(repState->Flags & FACTION_FLAG_AT_WAR)) return false; } } @@ -12685,7 +12687,6 @@ void Unit::setDeathState(DeathState s) { // death state needs to be updated before RemoveAllAurasOnDeath() calls HandleChannelDeathItem(..) so that // it can be used to check creation of death items (such as soul shards). - DeathState oldDeathState = m_deathState; m_deathState = s; if (s != ALIVE && s != JUST_ALIVED) @@ -14825,7 +14826,7 @@ Unit* Unit::SelectNearbyTarget(Unit* exclude, float dist) const // remove current target if (getVictim()) targets.remove(getVictim()); - + if (exclude) targets.remove(exclude); @@ -15327,14 +15328,6 @@ void Unit::Kill(Unit* victim, bool durabilityLoss) if (!victim->GetHealth()) return; - // Inform pets (if any) when player kills target) - if (Player* player = ToPlayer()) - { - Pet* pet = player->GetPet(); - if (pet && pet->isAlive() && pet->isControlled()) - pet->AI()->KilledUnit(victim); - } - // find player: owner of controlled `this` or `this` itself maybe Player* player = GetCharmerOrOwnerPlayerOrPlayerItself(); Creature* creature = victim->ToCreature(); @@ -15463,6 +15456,16 @@ void Unit::Kill(Unit* victim, bool durabilityLoss) victim->setDeathState(JUST_DIED); } + // Inform pets (if any) when player kills target) + // MUST come after victim->setDeathState(JUST_DIED); or pet next target + // selection will get stuck on same target and break pet react state + if (Player* player = ToPlayer()) + { + Pet* pet = player->GetPet(); + if (pet && pet->isAlive() && pet->isControlled()) + pet->AI()->KilledUnit(victim); + } + // 10% durability loss on death // clean InHateListOf if (Player* plrVictim = victim->ToPlayer()) @@ -16875,57 +16878,61 @@ void Unit::JumpTo(WorldObject* obj, float speedZ) bool Unit::HandleSpellClick(Unit* clicker, int8 seatId) { - bool success = false; uint32 spellClickEntry = GetVehicleKit() ? GetVehicleKit()->GetCreatureEntry() : GetEntry(); SpellClickInfoMapBounds clickPair = sObjectMgr->GetSpellClickInfoMapBounds(spellClickEntry); for (SpellClickInfoContainer::const_iterator itr = clickPair.first; itr != clickPair.second; ++itr) { - if (itr->second.IsFitToRequirements(clicker, this)) + //! First check simple relations from clicker to clickee + if (!itr->second.IsFitToRequirements(clicker, this)) + return false; + + //! Check database conditions + ConditionList conds = sConditionMgr->GetConditionsForSpellClickEvent(spellClickEntry, itr->second.spellId); + ConditionSourceInfo info = ConditionSourceInfo(clicker, this); + if (!sConditionMgr->IsObjectMeetToConditions(info, conds)) + return false; + + Unit* caster = (itr->second.castFlags & NPC_CLICK_CAST_CASTER_CLICKER) ? clicker : this; + Unit* target = (itr->second.castFlags & NPC_CLICK_CAST_TARGET_CLICKER) ? clicker : this; + uint64 origCasterGUID = (itr->second.castFlags & NPC_CLICK_CAST_ORIG_CASTER_OWNER) ? GetOwnerGUID() : clicker->GetGUID(); + + SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(itr->second.spellId); + // if (!spellEntry) should be checked at npc_spellclick load + + if (seatId > -1) { - Unit* caster = (itr->second.castFlags & NPC_CLICK_CAST_CASTER_CLICKER) ? clicker : this; - Unit* target = (itr->second.castFlags & NPC_CLICK_CAST_TARGET_CLICKER) ? clicker : this; - uint64 origCasterGUID = (itr->second.castFlags & NPC_CLICK_CAST_ORIG_CASTER_OWNER) ? GetOwnerGUID() : clicker->GetGUID(); - - SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(itr->second.spellId); - // if (!spellEntry) should be checked at npc_spellclick load - - if (seatId > -1) + uint8 i = 0; + bool valid = false; + while (i < MAX_SPELL_EFFECTS && !valid) { - uint8 i = 0; - bool valid = false; - while (i < MAX_SPELL_EFFECTS && !valid) + if (spellEntry->Effects[i].ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE) { - if (spellEntry->Effects[i].ApplyAuraName == SPELL_AURA_CONTROL_VEHICLE) - { - valid = true; - break; - } - ++i; - } - - if (!valid) - { - sLog->outErrorDb("Spell %u specified in npc_spellclick_spells is not a valid vehicle enter aura!", itr->second.spellId); - return false; - } - - if (IsInMap(caster)) - caster->CastCustomSpell(itr->second.spellId, SpellValueMod(SPELLVALUE_BASE_POINT0+i), seatId+1, target, true, NULL, NULL, origCasterGUID); - else // This can happen during Player::_LoadAuras - { - int32 bp0 = seatId; - Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, &bp0, NULL, origCasterGUID); + valid = true; + break; } + ++i; } + + if (!valid) + { + sLog->outErrorDb("Spell %u specified in npc_spellclick_spells is not a valid vehicle enter aura!", itr->second.spellId); + return false; + } + + if (IsInMap(caster)) + caster->CastCustomSpell(itr->second.spellId, SpellValueMod(SPELLVALUE_BASE_POINT0+i), seatId+1, target, true, NULL, NULL, origCasterGUID); + else // This can happen during Player::_LoadAuras + { + int32 bp0 = seatId; + Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, &bp0, NULL, origCasterGUID); + } + } + else + { + if (IsInMap(caster)) + caster->CastSpell(target, spellEntry, true, NULL, NULL, origCasterGUID); else - { - if (IsInMap(caster)) - caster->CastSpell(target, spellEntry, true, NULL, NULL, origCasterGUID); - else - Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, NULL, NULL, origCasterGUID); - } - - success = true; + Aura::TryRefreshStackOrCreate(spellEntry, MAX_EFFECT_MASK, this, clicker, NULL, NULL, origCasterGUID); } } @@ -16933,7 +16940,7 @@ bool Unit::HandleSpellClick(Unit* clicker, int8 seatId) if (creature && creature->IsAIEnabled) creature->AI()->DoAction(EVENT_SPELLCLICK); - return success; + return true; } void Unit::EnterVehicle(Unit* base, int8 seatId) @@ -17398,7 +17405,11 @@ bool CharmInfo::IsCommandAttack() void CharmInfo::SaveStayPosition() { - m_unit->GetPosition(m_stayX, m_stayY, m_stayZ); + //! At this point a new spline destination is enabled because of Unit::StopMoving() + G3D::Vector3 const stayPos = m_unit->movespline->FinalDestination(); + m_stayX = stayPos.x; + m_stayY = stayPos.y; + m_stayZ = stayPos.z; } void CharmInfo::GetStayPosition(float &x, float &y, float &z) diff --git a/src/server/game/Entities/Unit/Unit.h b/src/server/game/Entities/Unit/Unit.h index 423f83844..66b0bcbeb 100755 --- a/src/server/game/Entities/Unit/Unit.h +++ b/src/server/game/Entities/Unit/Unit.h @@ -2008,7 +2008,8 @@ class Unit : public WorldObject uint32 BuildAuraStateUpdateForTarget(Unit* target) const; bool HasAuraState(AuraStateType flag, SpellInfo const* spellProto = NULL, Unit const* Caster = NULL) const ; void UnsummonAllTotems(); - Unit* SelectMagnetTarget(Unit* victim, SpellInfo const* spellInfo = NULL); + Unit* GetMagicHitRedirectTarget(Unit* victim, SpellInfo const* spellInfo); + Unit* GetMeleeHitRedirectTarget(Unit* victim, SpellInfo const* spellInfo = NULL); int32 SpellBaseDamageBonus(SpellSchoolMask schoolMask); int32 SpellBaseHealingBonus(SpellSchoolMask schoolMask); int32 SpellBaseDamageBonusForVictim(SpellSchoolMask schoolMask, Unit* pVictim); diff --git a/src/server/game/Entities/Vehicle/VehicleDefines.h b/src/server/game/Entities/Vehicle/VehicleDefines.h index 57d9204ad..df34a61d4 100644 --- a/src/server/game/Entities/Vehicle/VehicleDefines.h +++ b/src/server/game/Entities/Vehicle/VehicleDefines.h @@ -63,7 +63,7 @@ struct VehicleSeat struct VehicleAccessory { VehicleAccessory(uint32 entry, int8 seatId, bool isMinion, uint8 summonType, uint32 summonTime) : - AccessoryEntry(entry), SeatId(seatId), IsMinion(isMinion), SummonedType(summonType), SummonTime(summonTime) {} + AccessoryEntry(entry), IsMinion(isMinion), SummonTime(summonTime), SeatId(seatId), SummonedType(summonType) {} uint32 AccessoryEntry; uint32 IsMinion; uint32 SummonTime; diff --git a/src/server/game/Globals/ObjectMgr.cpp b/src/server/game/Globals/ObjectMgr.cpp index 2feb2eddf..f50d4144b 100755 --- a/src/server/game/Globals/ObjectMgr.cpp +++ b/src/server/game/Globals/ObjectMgr.cpp @@ -194,30 +194,8 @@ LanguageDesc const* GetLanguageDescByID(uint32 lang) bool SpellClickInfo::IsFitToRequirements(Unit const* clicker, Unit const* clickee) const { Player const* playerClicker = clicker->ToPlayer(); - if (playerClicker) - { - if (questStart) - { - // not in expected required quest state - if ((!questStartCanActive || !playerClicker->IsActiveQuest(questStart)) && !playerClicker->GetQuestRewardStatus(questStart)) - return false; - } - - if (questEnd) - { - // not in expected forbidden quest state - if (playerClicker->GetQuestRewardStatus(questEnd)) - return false; - } - } - - if (auraRequired) - if (!clicker->HasAura(auraRequired)) - return false; - - if (auraForbidden) - if (clicker->HasAura(auraForbidden)) - return false; + if (!playerClicker) + return true; Unit const* summoner = NULL; // Check summoners for party @@ -226,9 +204,6 @@ bool SpellClickInfo::IsFitToRequirements(Unit const* clicker, Unit const* clicke if (!summoner) summoner = clickee; - if (!playerClicker) - return true; - // This only applies to players switch (userType) { @@ -903,7 +878,8 @@ void ObjectMgr::LoadCreatureAddons() uint32 guid = fields[0].GetUInt32(); - if (_creatureDataStore.find(guid) == _creatureDataStore.end()) + CreatureData const* creData = GetCreatureData(guid); + if (!creData) { sLog->outErrorDb("Creature (GUID: %u) does not exist but has a record in `creature_addon`", guid); continue; @@ -912,6 +888,12 @@ void ObjectMgr::LoadCreatureAddons() CreatureAddon& creatureAddon = _creatureAddonStore[guid]; creatureAddon.path_id = fields[1].GetUInt32(); + if (creData->movementType == WAYPOINT_MOTION_TYPE && !creatureAddon.path_id) + { + const_cast(creData)->movementType = IDLE_MOTION_TYPE; + sLog->outErrorDb("Creature (GUID %u) has movement type set to WAYPOINT_MOTION_TYPE but no path assigned", guid); + } + creatureAddon.mount = fields[2].GetUInt32(); creatureAddon.bytes1 = fields[3].GetUInt32(); creatureAddon.bytes2 = fields[4].GetUInt32(); @@ -6701,7 +6683,7 @@ void ObjectMgr::LoadCorpses() PreparedQueryResult result = CharacterDatabase.Query(CharacterDatabase.GetPreparedStatement(CHAR_SEL_CORPSES)); if (!result) { - sLog->outString(">> Loaded 0 corpses. DB table `pet_name_generation` is empty."); + sLog->outString(">> Loaded 0 corpses. DB table `corpse` is empty."); sLog->outString(); return; } @@ -7110,8 +7092,8 @@ void ObjectMgr::LoadNPCSpellClickSpells() uint32 oldMSTime = getMSTime(); _spellClickInfoStore.clear(); - // 0 1 2 3 4 5 6 7 8 - QueryResult result = WorldDatabase.Query("SELECT npc_entry, spell_id, quest_start, quest_start_active, quest_end, cast_flags, aura_required, aura_forbidden, user_type FROM npc_spellclick_spells"); + // 0 1 2 3 + QueryResult result = WorldDatabase.Query("SELECT npc_entry, spell_id, cast_flags, user_type FROM npc_spellclick_spells"); if (!result) { @@ -7142,66 +7124,14 @@ void ObjectMgr::LoadNPCSpellClickSpells() continue; } - uint32 auraRequired = fields[6].GetUInt32(); - if (auraRequired) - { - SpellInfo const* aurReqInfo = sSpellMgr->GetSpellInfo(auraRequired); - if (!aurReqInfo) - { - sLog->outErrorDb("Table npc_spellclick_spells references unknown aura required %u. Skipping entry.", auraRequired); - continue; - } - } - - uint32 auraForbidden = fields[7].GetUInt32(); - if (auraForbidden) - { - SpellInfo const* aurForInfo = sSpellMgr->GetSpellInfo(auraForbidden); - if (!aurForInfo) - { - sLog->outErrorDb("Table npc_spellclick_spells references unknown aura forbidden %u. Skipping entry.", auraForbidden); - continue; - } - } - - uint32 quest_start = fields[2].GetUInt32(); - - // quest might be 0 to enable spellclick independent of any quest - if (quest_start) - { - if (_questTemplates.find(quest_start) == _questTemplates.end()) - { - sLog->outErrorDb("Table npc_spellclick_spells references unknown start quest %u. Skipping entry.", quest_start); - continue; - } - } - - bool quest_start_active = fields[3].GetBool(); - - uint32 quest_end = fields[4].GetUInt32(); - // quest might be 0 to enable spellclick active infinity after start quest - if (quest_end) - { - if (_questTemplates.find(quest_end) == _questTemplates.end()) - { - sLog->outErrorDb("Table npc_spellclick_spells references unknown end quest %u. Skipping entry.", quest_end); - continue; - } - } - - uint8 userType = fields[8].GetUInt8(); + uint8 userType = fields[3].GetUInt8(); if (userType >= SPELL_CLICK_USER_MAX) sLog->outErrorDb("Table npc_spellclick_spells references unknown user type %u. Skipping entry.", uint32(userType)); - uint8 castFlags = fields[5].GetUInt8(); + uint8 castFlags = fields[2].GetUInt8(); SpellClickInfo info; info.spellId = spellid; - info.questStart = quest_start; - info.questStartCanActive = quest_start_active; - info.questEnd = quest_end; info.castFlags = castFlags; - info.auraRequired = auraRequired; - info.auraForbidden = auraForbidden; info.userType = SpellClickUserTypes(userType); _spellClickInfoStore.insert(SpellClickInfoContainer::value_type(npc_entry, info)); diff --git a/src/server/game/Globals/ObjectMgr.h b/src/server/game/Globals/ObjectMgr.h index d7f2b4bab..11d16c0fb 100755 --- a/src/server/game/Globals/ObjectMgr.h +++ b/src/server/game/Globals/ObjectMgr.h @@ -337,12 +337,7 @@ std::string GetScriptCommandName(ScriptCommands command); struct SpellClickInfo { uint32 spellId; - uint32 questStart; // quest start (quest must be active or rewarded for spell apply) - uint32 questEnd; // quest end (quest must not be rewarded for spell apply) - bool questStartCanActive; // if true then quest start can be active (not only rewarded) uint8 castFlags; - uint32 auraRequired; - uint32 auraForbidden; SpellClickUserTypes userType; // helpers diff --git a/src/server/game/Grids/Notifiers/GridNotifiers.h b/src/server/game/Grids/Notifiers/GridNotifiers.h index 4112711ad..12e3fda04 100755 --- a/src/server/game/Grids/Notifiers/GridNotifiers.h +++ b/src/server/game/Grids/Notifiers/GridNotifiers.h @@ -530,26 +530,24 @@ namespace Trinity class RaiseDeadObjectCheck { public: - RaiseDeadObjectCheck(Unit* source, float range) : _source(source), i_range(range) {} + RaiseDeadObjectCheck(Unit* source, float range) : _source(source), _range(range) {} bool operator()(Creature* u) { if (_source->GetTypeId() != TYPEID_PLAYER || !((Player*)_source)->isHonorOrXPTarget(u) || - u->getDeathState() != CORPSE || + u->getDeathState() != CORPSE || (u->GetCreatureTypeMask() & (1 << (CREATURE_TYPE_HUMANOID-1))) == 0 || (u->GetDisplayId() != u->GetNativeDisplayId())) return false; - return _source->IsWithinDistInMap(u, i_range); + return _source->IsWithinDistInMap(u, _range); } - bool operator()(Player* u) { if (_source == u || _source->GetTypeId() != TYPEID_PLAYER || !((Player*)_source)->isHonorOrXPTarget(u) || u->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST) || u->isInFlight() || !u->isDead() || (u->GetCreatureTypeMask() & (1 << (CREATURE_TYPE_HUMANOID-1))) == 0) return false; - - return _source->IsWithinDistInMap(u, i_range); + return _source->IsWithinDistInMap(u, _range); } bool operator()(Corpse* u) @@ -557,12 +555,12 @@ namespace Trinity if (_source->GetTypeId() != TYPEID_PLAYER || u->GetType() == CORPSE_BONES) return false; - return _source->IsWithinDistInMap(u, i_range); + return _source->IsWithinDistInMap(u, _range); } template bool operator()(NOT_INTERESTED*) { return false; } private: Unit* const _source; - float i_range; + float _range; }; class ExplodeCorpseObjectCheck diff --git a/src/server/game/Groups/Group.cpp b/src/server/game/Groups/Group.cpp index fa0259219..cee4b25eb 100755 --- a/src/server/game/Groups/Group.cpp +++ b/src/server/game/Groups/Group.cpp @@ -557,7 +557,7 @@ bool Group::RemoveMember(uint64 guid, const RemoveMethod &method /*= GROUP_REMOV { Player* Leader = ObjectAccessor::FindPlayer(GetLeaderGUID()); LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(sLFGMgr->GetDungeon(GetGUID())); - if ((Leader && dungeon && Leader->isAlive() && Leader->GetMapId() != dungeon->map) || !dungeon) + if ((Leader && dungeon && Leader->isAlive() && Leader->GetMapId() != uint32(dungeon->map)) || !dungeon) { Disband(); return false; diff --git a/src/server/game/Handlers/AuctionHouseHandler.cpp b/src/server/game/Handlers/AuctionHouseHandler.cpp index fc87d3ed8..f99bfe52d 100755 --- a/src/server/game/Handlers/AuctionHouseHandler.cpp +++ b/src/server/game/Handlers/AuctionHouseHandler.cpp @@ -123,6 +123,12 @@ void WorldSession::HandleAuctionSellItem(WorldPacket & recv_data) uint64 itemGUIDs[MAX_AUCTION_ITEMS]; // 160 slot = 4x 36 slot bag + backpack 16 slot uint32 count[MAX_AUCTION_ITEMS]; + if (itemsCount > MAX_AUCTION_ITEMS) + { + SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR); + return; + } + for (uint32 i = 0; i < itemsCount; ++i) { recv_data >> itemGUIDs[i]; @@ -153,12 +159,6 @@ void WorldSession::HandleAuctionSellItem(WorldPacket & recv_data) return; } - if (itemsCount > MAX_AUCTION_ITEMS) - { - SendAuctionCommandResult(0, AUCTION_SELL_ITEM, AUCTION_INTERNAL_ERROR); - return; - } - etime *= MINUTE; switch(etime) @@ -188,7 +188,7 @@ void WorldSession::HandleAuctionSellItem(WorldPacket & recv_data) return; } - if (sAuctionMgr->GetAItem(item->GetGUIDLow()) || !item->CanBeTraded() || item->IsNotEmptyBag() || + if (sAuctionMgr->GetAItem(item->GetGUIDLow()) || !item->CanBeTraded() || item->IsNotEmptyBag() || item->GetTemplate()->Flags & ITEM_PROTO_FLAG_CONJURED || item->GetUInt32Value(ITEM_FIELD_DURATION) || item->GetCount() < count[i]) { diff --git a/src/server/game/Handlers/CalendarHandler.cpp b/src/server/game/Handlers/CalendarHandler.cpp index be547c84b..820079a90 100755 --- a/src/server/game/Handlers/CalendarHandler.cpp +++ b/src/server/game/Handlers/CalendarHandler.cpp @@ -88,7 +88,7 @@ void WorldSession::HandleCalendarGetCalendar(WorldPacket& /*recv_data*/) data << uint32(counter); // raid reset count std::set sentMaps; - + ResetTimeByMapDifficultyMap const& resets = sInstanceSaveMgr->GetResetTimeMap(); for (ResetTimeByMapDifficultyMap::const_iterator itr = resets.begin(); itr != resets.end(); ++itr) { @@ -102,7 +102,7 @@ void WorldSession::HandleCalendarGetCalendar(WorldPacket& /*recv_data*/) continue; sentMaps.insert(mapId); - + data << uint32(mapId); data << uint32(itr->second - cur_time); data << uint32(mapEntry->unk_time); diff --git a/src/server/game/Handlers/CharacterHandler.cpp b/src/server/game/Handlers/CharacterHandler.cpp index 310bda927..a48cf70bd 100644 --- a/src/server/game/Handlers/CharacterHandler.cpp +++ b/src/server/game/Handlers/CharacterHandler.cpp @@ -197,7 +197,7 @@ bool LoginQueryHolder::Initialize() stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ACCOUNT_INSTANCELOCKTIMES); stmt->setUInt32(0, m_accountId); res &= SetPreparedQuery(PLAYER_LOGIN_QUERY_LOADINSTANCELOCKTIMES, stmt); - + return res; } @@ -615,6 +615,7 @@ void WorldSession::HandleCharCreateCallback(PreparedQueryResult result, Characte } Player newChar(this); + newChar.GetMotionMaster()->Initialize(); if (!newChar.Create(sObjectMgr->GenerateLowGuid(HIGHGUID_PLAYER), createInfo)) { // Player not create (race/class/etc problem?) diff --git a/src/server/game/Handlers/MiscHandler.cpp b/src/server/game/Handlers/MiscHandler.cpp index d40438494..6e079e950 100755 --- a/src/server/game/Handlers/MiscHandler.cpp +++ b/src/server/game/Handlers/MiscHandler.cpp @@ -1174,16 +1174,6 @@ void WorldSession::HandleSetActionBarToggles(WorldPacket& recv_data) GetPlayer()->SetByteValue(PLAYER_FIELD_BYTES, 2, ActionBar); } -void WorldSession::HandleWardenDataOpcode(WorldPacket& recv_data) -{ - recv_data.read_skip(); - /* - uint8 tmp; - recv_data >> tmp; - sLog->outDebug("Received opcode CMSG_WARDEN_DATA, not resolve.uint8 = %u", tmp); - */ -} - void WorldSession::HandlePlayedTime(WorldPacket& recv_data) { uint8 unk1; diff --git a/src/server/game/Handlers/PetHandler.cpp b/src/server/game/Handlers/PetHandler.cpp index 16b6a4bb7..8da768345 100755 --- a/src/server/game/Handlers/PetHandler.cpp +++ b/src/server/game/Handlers/PetHandler.cpp @@ -155,6 +155,7 @@ void WorldSession::HandlePetActionHelper(Unit* pet, uint64 guid1, uint16 spellid case COMMAND_STAY: //flat=1792 //STAY pet->AttackStop(); pet->InterruptNonMeleeSpells(false); + pet->StopMoving(); pet->GetMotionMaster()->Clear(false); pet->GetMotionMaster()->MoveIdle(); charmInfo->SetCommandState(COMMAND_STAY); diff --git a/src/server/game/Handlers/SpellHandler.cpp b/src/server/game/Handlers/SpellHandler.cpp index b8908d0f9..9ea0e1241 100755 --- a/src/server/game/Handlers/SpellHandler.cpp +++ b/src/server/game/Handlers/SpellHandler.cpp @@ -165,24 +165,6 @@ void WorldSession::HandleUseItemOpcode(WorldPacket& recvPacket) targets.Read(recvPacket, pUser); HandleClientCastFlags(recvPacket, castFlags, targets); - if (!pItem->IsTargetValidForItemUse(targets.GetUnitTarget())) - { - // free gray item after use fail - pUser->SendEquipError(EQUIP_ERR_NONE, pItem, NULL); - - // send spell error - if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId)) - { - // for implicit area/coord target spells - if (!targets.GetUnitTarget()) - Spell::SendCastResult(_player, spellInfo, castCount, SPELL_FAILED_NO_VALID_TARGETS); - // for explicit target spells - else - Spell::SendCastResult(_player, spellInfo, castCount, SPELL_FAILED_BAD_TARGETS); - } - return; - } - // Note: If script stop casting it must send appropriate data to client to prevent stuck item in gray state. if (!sScriptMgr->OnItemUse(pUser, pItem, targets)) { diff --git a/src/server/game/Handlers/TaxiHandler.cpp b/src/server/game/Handlers/TaxiHandler.cpp index 8eb1eab06..44889e6dd 100755 --- a/src/server/game/Handlers/TaxiHandler.cpp +++ b/src/server/game/Handlers/TaxiHandler.cpp @@ -292,3 +292,12 @@ void WorldSession::HandleActivateTaxiOpcode(WorldPacket & recv_data) GetPlayer()->ActivateTaxiPathTo(nodes, npc); } + +void WorldSession::SendActivateTaxiReply(ActivateTaxiReply reply) +{ + WorldPacket data(SMSG_ACTIVATETAXIREPLY, 4); + data << uint32(reply); + SendPacket(&data); + + sLog->outDebug(LOG_FILTER_NETWORKIO, "WORLD: Sent SMSG_ACTIVATETAXIREPLY"); +} diff --git a/src/server/game/Instances/InstanceScript.cpp b/src/server/game/Instances/InstanceScript.cpp index 90fb8ffb9..c6a93ff42 100755 --- a/src/server/game/Instances/InstanceScript.cpp +++ b/src/server/game/Instances/InstanceScript.cpp @@ -316,7 +316,7 @@ void InstanceScript::DoSendNotifyToInstance(char const* format, ...) for (Map::PlayerList::const_iterator i = players.begin(); i != players.end(); ++i) if (Player* player = i->getSource()) if (WorldSession* session = player->GetSession()) - session->SendNotification(buff); + session->SendNotification("%s", buff); } } diff --git a/src/server/game/Loot/LootMgr.cpp b/src/server/game/Loot/LootMgr.cpp index 564d0cce8..64e9b9a27 100755 --- a/src/server/game/Loot/LootMgr.cpp +++ b/src/server/game/Loot/LootMgr.cpp @@ -1364,7 +1364,7 @@ bool LootTemplate::addConditionItem(Condition* cond) { for (LootStoreItemList::iterator i = Entries.begin(); i != Entries.end(); ++i) { - if (i->itemid == cond->SourceEntry) + if (i->itemid == uint32(cond->SourceEntry)) { i->conditions.push_back(cond); return true; @@ -1380,7 +1380,7 @@ bool LootTemplate::addConditionItem(Condition* cond) { for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i) { - if ((*i).itemid == cond->SourceEntry) + if ((*i).itemid == uint32(cond->SourceEntry)) { (*i).conditions.push_back(cond); return true; @@ -1392,7 +1392,7 @@ bool LootTemplate::addConditionItem(Condition* cond) { for (LootStoreItemList::iterator i = itemList->begin(); i != itemList->end(); ++i) { - if ((*i).itemid == cond->SourceEntry) + if ((*i).itemid == uint32(cond->SourceEntry)) { (*i).conditions.push_back(cond); return true; diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp index 39f695c08..f6189fa55 100755 --- a/src/server/game/Maps/Map.cpp +++ b/src/server/game/Maps/Map.cpp @@ -666,10 +666,11 @@ void Map::RemovePlayerFromMap(Player* player, bool remove) ASSERT(remove); //maybe deleted in logoutplayer when player is not in a map if (remove) + { DeleteFromWorld(player); - if (remove) sScriptMgr->OnPlayerLeaveMap(this, player); + } } template @@ -1555,7 +1556,7 @@ float Map::GetWaterOrGroundLevel(float x, float y, float z, float* ground /*= NU LiquidData liquid_status; ZLiquidStatus res = getLiquidStatus(x, y, ground_z, MAP_ALL_LIQUIDS, &liquid_status); - return res ? ( swim ? liquid_status.level - 2.0f : liquid_status.level) : ground_z; + return res ? liquid_status.level : ground_z; } return VMAP_INVALID_HEIGHT_VALUE; @@ -2374,7 +2375,7 @@ bool InstanceMap::AddPlayerToMap(Player* player) if (uint32 dungeonId = sLFGMgr->GetDungeon(group->GetGUID(), true)) if (LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(dungeonId)) if (LFGDungeonEntry const* randomDungeon = sLFGDungeonStore.LookupEntry(*(sLFGMgr->GetSelectedDungeons(player->GetGUID()).begin()))) - if (dungeon->map == GetId() && dungeon->difficulty == GetDifficulty() && randomDungeon->type == LFG_TYPE_RANDOM) + if (uint32(dungeon->map) == GetId() && dungeon->difficulty == GetDifficulty() && randomDungeon->type == LFG_TYPE_RANDOM) player->CastSpell(player, LFG_SPELL_LUCK_OF_THE_DRAW, true); } diff --git a/src/server/game/Maps/Map.h b/src/server/game/Maps/Map.h index 9f4dbb23b..d8db4c947 100755 --- a/src/server/game/Maps/Map.h +++ b/src/server/game/Maps/Map.h @@ -171,7 +171,7 @@ class GridMap uint8 _liquidOffY; uint8 _liquidWidth; uint8 _liquidHeight; - + bool loadAreaData(FILE* in, uint32 offset, uint32 size); bool loadHeihgtData(FILE* in, uint32 offset, uint32 size); diff --git a/src/server/game/Miscellaneous/SharedDefines.h b/src/server/game/Miscellaneous/SharedDefines.h index f5f8133eb..fbc84b85a 100755 --- a/src/server/game/Miscellaneous/SharedDefines.h +++ b/src/server/game/Miscellaneous/SharedDefines.h @@ -3405,4 +3405,21 @@ enum RemoveMethod GROUP_REMOVEMETHOD_LEAVE = 2, }; +enum ActivateTaxiReply +{ + ERR_TAXIOK = 0, + ERR_TAXIUNSPECIFIEDSERVERERROR = 1, + ERR_TAXINOSUCHPATH = 2, + ERR_TAXINOTENOUGHMONEY = 3, + ERR_TAXITOOFARAWAY = 4, + ERR_TAXINOVENDORNEARBY = 5, + ERR_TAXINOTVISITED = 6, + ERR_TAXIPLAYERBUSY = 7, + ERR_TAXIPLAYERALREADYMOUNTED = 8, + ERR_TAXIPLAYERSHAPESHIFTED = 9, + ERR_TAXIPLAYERMOVING = 10, + ERR_TAXISAMENODE = 11, + ERR_TAXINOTSTANDING = 12 +}; + #endif diff --git a/src/server/game/Movement/MotionMaster.h b/src/server/game/Movement/MotionMaster.h index 83ff81ab3..9910f8ad4 100755 --- a/src/server/game/Movement/MotionMaster.h +++ b/src/server/game/Movement/MotionMaster.h @@ -91,7 +91,7 @@ class MotionMaster //: private std::stack void InitTop(); public: - explicit MotionMaster(Unit* unit) : _top(-1), _owner(unit), _expList(NULL), _cleanFlag(MMCF_NONE) + explicit MotionMaster(Unit* unit) : _expList(NULL), _top(-1), _owner(unit), _cleanFlag(MMCF_NONE) { for (uint8 i = 0; i < MAX_MOTION_SLOT; ++i) { diff --git a/src/server/game/Movement/MovementGenerators/HomeMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/HomeMovementGenerator.cpp index dc4789835..5725aec54 100755 --- a/src/server/game/Movement/MovementGenerators/HomeMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/HomeMovementGenerator.cpp @@ -57,7 +57,7 @@ void HomeMovementGenerator::_setTargetLocation(Creature & owner) owner.ClearUnitState(UNIT_STATE_ALL_STATE & ~UNIT_STATE_EVADE); } -bool HomeMovementGenerator::Update(Creature &owner, const uint32 time_diff) +bool HomeMovementGenerator::Update(Creature &owner, const uint32 /*time_diff*/) { arrived = owner.movespline->Finalized(); return !arrived; diff --git a/src/server/game/Movement/MovementGenerators/PointMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/PointMovementGenerator.cpp index 02f9ebce8..c565e1507 100755 --- a/src/server/game/Movement/MovementGenerators/PointMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/PointMovementGenerator.cpp @@ -41,7 +41,7 @@ void PointMovementGenerator::Initialize(T &unit) } template -bool PointMovementGenerator::Update(T &unit, const uint32 &diff) +bool PointMovementGenerator::Update(T &unit, const uint32 & /*diff*/) { if (!&unit) return false; diff --git a/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp index 054f87d9f..b65fa2107 100755 --- a/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/RandomMovementGenerator.cpp @@ -35,9 +35,8 @@ template<> void RandomMovementGenerator::_setRandomLocation(Creature& creature) { - float respX, respY, respZ, respO, currZ, destX, destY, destZ, travelDistZ; + float respX, respY, respZ, respO, destX, destY, destZ, travelDistZ; creature.GetHomePosition(respX, respY, respZ, respO); - currZ = creature.GetPositionZ(); Map const* map = creature.GetBaseMap(); // For 2D/3D system selection diff --git a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp index 964b44024..064a8fc82 100755 --- a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp @@ -38,15 +38,18 @@ void TargetedMovementGeneratorMedium::_setTargetLocation(T &owner) return; float x, y, z; - - if (i_offset && i_target->IsWithinDistInMap(&owner,2*i_offset)) - { - if (!owner.movespline->Finalized()) - return; - - owner.GetPosition(x, y, z); - } - else if (!i_offset) + //! Following block of code deleted by MrSmite in issue 4891 + //! Code kept for learning and diagnostical purposes +// +// if (i_offset && i_target->IsWithinDistInMap(&owner,2*i_offset)) +// { +// if (!owner.movespline->Finalized()) +// return; +// +// owner.GetPosition(x, y, z); +// } +// else + if (!i_offset) { if (i_target->IsWithinMeleeRange(&owner)) return; diff --git a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h index bf2eecc89..b851dbc0e 100755 --- a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h +++ b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h @@ -39,8 +39,9 @@ class TargetedMovementGeneratorMedium { protected: TargetedMovementGeneratorMedium(Unit &target, float offset, float angle) : - TargetedMovementGeneratorBase(target), i_offset(offset), i_angle(angle), - i_recalculateTravel(false), i_targetReached(false), i_recheckDistance(0) + TargetedMovementGeneratorBase(target), i_recheckDistance(0), + i_offset(offset), i_angle(angle), + i_recalculateTravel(false), i_targetReached(false) { } ~TargetedMovementGeneratorMedium() {} diff --git a/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.cpp index 55cf3c28d..fb2249c50 100755 --- a/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.cpp @@ -78,7 +78,7 @@ void WaypointMovementGenerator::OnArrived(Creature& creature) if (i_path->at(i_currentNode)->event_id && urand(0, 99) < i_path->at(i_currentNode)->event_chance) { - sLog->outDebug(LOG_FILTER_MAPSCRIPTS, "Creature movement start script %u at point %u for %u.", i_path->at(i_currentNode)->event_id, i_currentNode, creature.GetGUID()); + sLog->outDebug(LOG_FILTER_MAPSCRIPTS, "Creature movement start script %u at point %u for "UI64FMTD".", i_path->at(i_currentNode)->event_id, i_currentNode, creature.GetGUID()); creature.GetMap()->ScriptsStart(sWaypointScripts, i_path->at(i_currentNode)->event_id, &creature, NULL/*, false*/); } @@ -111,8 +111,8 @@ bool WaypointMovementGenerator::StartMove(Creature &creature) m_isArrivalDone = false; - creature.AddUnitState(UNIT_STATE_ROAMING_MOVE); - + creature.AddUnitState(UNIT_STATE_ROAMING_MOVE); + Movement::MoveSplineInit init(creature); init.MoveTo(node->x, node->y, node->z); @@ -147,7 +147,7 @@ bool WaypointMovementGenerator::Update(Creature &creature, const uint3 if (CanMove(diff)) return StartMove(creature); } - else + else { if (creature.IsStopped()) Stop(STOP_TIME_FOR_PLAYER); @@ -155,7 +155,7 @@ bool WaypointMovementGenerator::Update(Creature &creature, const uint3 { OnArrived(creature); return StartMove(creature); - } + } } return true; } @@ -201,20 +201,17 @@ void FlightPathMovementGenerator::Initialize(Player &player) InitEndGridInfo(); } -void FlightPathMovementGenerator::Finalize(Player & player) +void FlightPathMovementGenerator::Finalize(Player& player) { // remove flag to prevent send object build movement packets for flight state and crash (movement generator already not at top of stack) player.ClearUnitState(UNIT_STATE_IN_FLIGHT); player.Dismount(); - player.RemoveFlag(UNIT_FIELD_FLAGS,UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_TAXI_FLIGHT); + player.RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_DISABLE_MOVE | UNIT_FLAG_TAXI_FLIGHT); - if(player.m_taxi.empty()) + if (player.m_taxi.empty()) { player.getHostileRefManager().setOnlineOfflineState(true); - if(player.pvpInfo.inHostileArea) - player.CastSpell(&player, 2479, true); - // update z position to ground and orientation for landing point // this prevent cheating with landing point at lags // when client side flight end early in comparison server side @@ -243,7 +240,7 @@ void FlightPathMovementGenerator::Reset(Player & player) init.Launch(); } -bool FlightPathMovementGenerator::Update(Player &player, const uint32 diff) +bool FlightPathMovementGenerator::Update(Player &player, const uint32 /*diff*/) { uint32 pointId = (uint32)player.movespline->currentPathIdx(); if (pointId > i_currentNode) @@ -296,7 +293,7 @@ bool FlightPathMovementGenerator::GetResetPosition(Player&, float& x, float& y, x = node.x; y = node.y; z = node.z; return true; } - + void FlightPathMovementGenerator::InitEndGridInfo() { /*! Storage to preload flightmaster grid at end of flight. For multi-stop flights, this will diff --git a/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.h b/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.h index aa6d327db..9c2475267 100755 --- a/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.h +++ b/src/server/game/Movement/MovementGenerators/WaypointMovementGenerator.h @@ -42,7 +42,7 @@ template class PathMovementBase { public: - PathMovementBase() : i_currentNode(0), i_path(NULL) {} + PathMovementBase() : i_path(NULL), i_currentNode(0) {} virtual ~PathMovementBase() {}; // template pattern, not defined .. override required @@ -63,7 +63,8 @@ class WaypointMovementGenerator public PathMovementBase { public: - WaypointMovementGenerator(uint32 _path_id = 0, bool _repeating = true) : i_nextMoveTime(0), path_id(_path_id), m_isArrivalDone(false), repeating(_repeating) {} + WaypointMovementGenerator(uint32 _path_id = 0, bool _repeating = true) + : i_nextMoveTime(0), m_isArrivalDone(false), path_id(_path_id), repeating(_repeating) {} ~WaypointMovementGenerator() { i_path = NULL; } void Initialize(Creature &); void Finalize(Creature &); diff --git a/src/server/game/Movement/Spline/MoveSpline.cpp b/src/server/game/Movement/Spline/MoveSpline.cpp index 4eaa6b57b..5d0344f97 100644 --- a/src/server/game/Movement/Spline/MoveSpline.cpp +++ b/src/server/game/Movement/Spline/MoveSpline.cpp @@ -187,7 +187,7 @@ void MoveSpline::Initialize(const MoveSplineInitArgs& args) } MoveSpline::MoveSpline() : m_Id(0), time_passed(0), - vertical_acceleration(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0), initialOrientation(0.f) + vertical_acceleration(0.f), initialOrientation(0.f), effect_start_time(0), point_Idx(0), point_Idx_offset(0) { splineflags.done = true; } diff --git a/src/server/game/Movement/Spline/MoveSpline.h b/src/server/game/Movement/Spline/MoveSpline.h index 4b8dbcc8e..d4b19b216 100644 --- a/src/server/game/Movement/Spline/MoveSpline.h +++ b/src/server/game/Movement/Spline/MoveSpline.h @@ -47,7 +47,6 @@ namespace Movement Result_NextCycle = 0x04, Result_NextSegment = 0x08, }; - #pragma region fields friend class PacketBuilder; protected: MySpline spline; @@ -88,7 +87,6 @@ namespace Movement void _Finalize(); void _Interrupt() { splineflags.done = true;} - #pragma endregion public: void Initialize(const MoveSplineInitArgs&); diff --git a/src/server/game/Movement/Spline/MoveSplineFlag.h b/src/server/game/Movement/Spline/MoveSplineFlag.h index de91f63c3..33973064e 100644 --- a/src/server/game/Movement/Spline/MoveSplineFlag.h +++ b/src/server/game/Movement/Spline/MoveSplineFlag.h @@ -98,14 +98,14 @@ namespace Movement void operator &= (uint32 f) { raw() &= f;} void operator |= (uint32 f) { raw() |= f;} - void EnableAnimation(uint8 anim) { raw() = raw() & ~(Mask_Animations|Falling|Parabolic) | Animation|anim;} - void EnableParabolic() { raw() = raw() & ~(Mask_Animations|Falling|Animation) | Parabolic;} - void EnableFalling() { raw() = raw() & ~(Mask_Animations|Parabolic|Animation) | Falling;} - void EnableFlying() { raw() = raw() & ~Catmullrom | Flying; } - void EnableCatmullRom() { raw() = raw() & ~Flying | Catmullrom; } - void EnableFacingPoint() { raw() = raw() & ~Mask_Final_Facing | Final_Point;} - void EnableFacingAngle() { raw() = raw() & ~Mask_Final_Facing | Final_Angle;} - void EnableFacingTarget() { raw() = raw() & ~Mask_Final_Facing | Final_Target;} + void EnableAnimation(uint8 anim) { raw() = (raw() & ~(Mask_Animations|Falling|Parabolic)) | Animation|anim;} + void EnableParabolic() { raw() = (raw() & ~(Mask_Animations|Falling|Animation)) | Parabolic;} + void EnableFalling() { raw() = (raw() & ~(Mask_Animations|Parabolic|Animation)) | Falling;} + void EnableFlying() { raw() = (raw() & ~Catmullrom) | Flying; } + void EnableCatmullRom() { raw() = (raw() & ~Flying) | Catmullrom; } + void EnableFacingPoint() { raw() = (raw() & ~Mask_Final_Facing) | Final_Point;} + void EnableFacingAngle() { raw() = (raw() & ~Mask_Final_Facing) | Final_Angle;} + void EnableFacingTarget() { raw() = (raw() & ~Mask_Final_Facing) | Final_Target;} uint8 animId : 8; bool done : 1; diff --git a/src/server/game/Movement/Spline/Spline.cpp b/src/server/game/Movement/Spline/Spline.cpp index 14c1bd0c1..6970acf54 100644 --- a/src/server/game/Movement/Spline/Spline.cpp +++ b/src/server/game/Movement/Spline/Spline.cpp @@ -56,7 +56,6 @@ SplineBase::InitMethtod SplineBase::initializers[SplineBase::ModesEnd] = }; /////////// -#pragma region evaluation methtods using G3D::Matrix4; static const Matrix4 s_catmullRomCoeffs( @@ -199,7 +198,6 @@ float SplineBase::SegLengthBezier3(index_type index) const } return length; } -#pragma endregion void SplineBase::init_spline(const Vector3 * controls, index_type count, EvaluationMode m) { diff --git a/src/server/game/Movement/Spline/Spline.h b/src/server/game/Movement/Spline/Spline.h index 28876b220..627cdcf3e 100644 --- a/src/server/game/Movement/Spline/Spline.h +++ b/src/server/game/Movement/Spline/Spline.h @@ -39,7 +39,6 @@ public: ModesEnd }; - #pragma region fields protected: ControlArray points; @@ -84,10 +83,9 @@ protected: void UninitializedSpline() const { ASSERT(false);} - #pragma endregion public: - explicit SplineBase() : m_mode(UninitializedMode), index_lo(0), index_hi(0), cyclic(false) {} + explicit SplineBase() : index_lo(0), index_hi(0), m_mode(UninitializedMode), cyclic(false) {} /** Caclulates the position for given segment Idx, and percent of segment length t @param t - percent of segment length, assumes that t in range [0, 1] @@ -138,13 +136,11 @@ class Spline : public SplineBase public: typedef length_type LengthType; typedef std::vector LengthArray; - #pragma region fields protected: LengthArray lengths; index_type computeIndexInBounds(length_type length) const; - #pragma endregion public: explicit Spline(){} diff --git a/src/server/game/Quests/QuestDef.h b/src/server/game/Quests/QuestDef.h index eaaaeaac9..21b98ad2c 100755 --- a/src/server/game/Quests/QuestDef.h +++ b/src/server/game/Quests/QuestDef.h @@ -360,7 +360,7 @@ class Quest struct QuestStatusData { - QuestStatusData(): Status(QUEST_STATUS_NONE), Explored(false), Timer(0), PlayerCount(0) + QuestStatusData(): Status(QUEST_STATUS_NONE), Timer(0), PlayerCount(0), Explored(false) { memset(ItemCount, 0, QUEST_ITEM_OBJECTIVES_COUNT * sizeof(uint16)); memset(CreatureOrGOCount, 0, QUEST_OBJECTIVES_COUNT * sizeof(uint16)); diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp index 87bd1c62f..f8f616d89 100755 --- a/src/server/game/Server/Protocol/Opcodes.cpp +++ b/src/server/game/Server/Protocol/Opcodes.cpp @@ -769,7 +769,7 @@ OpcodeHandler opcodeTable[NUM_MSG_TYPES] = /*0x2E4*/ { "SMSG_AREA_SPIRIT_HEALER_TIME", STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide }, /*0x2E5*/ { "CMSG_GM_UNTEACH", STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_NULL }, /*0x2E6*/ { "SMSG_WARDEN_DATA", STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide }, - /*0x2E7*/ { "CMSG_WARDEN_DATA", STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleWardenDataOpcode }, + /*0x2E7*/ { "CMSG_WARDEN_DATA", STATUS_AUTHED, PROCESS_THREADUNSAFE, &WorldSession::HandleWardenDataOpcode }, /*0x2E8*/ { "SMSG_GROUP_JOINED_BATTLEGROUND", STATUS_NEVER, PROCESS_INPLACE, &WorldSession::Handle_ServerSide }, /*0x2E9*/ { "MSG_BATTLEGROUND_PLAYER_POSITIONS", STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandleBattlegroundPlayerPositionsOpcode}, /*0x2EA*/ { "CMSG_PET_STOP_ATTACK", STATUS_LOGGEDIN, PROCESS_THREADUNSAFE, &WorldSession::HandlePetStopAttack }, diff --git a/src/server/game/Server/WorldSession.cpp b/src/server/game/Server/WorldSession.cpp index ab107fd05..211ca42d3 100755 --- a/src/server/game/Server/WorldSession.cpp +++ b/src/server/game/Server/WorldSession.cpp @@ -42,6 +42,8 @@ #include "zlib.h" #include "ScriptMgr.h" #include "Transport.h" +#include "WardenWin.h" +#include "WardenMac.h" bool MapSessionFilter::Process(WorldPacket* packet) { @@ -96,6 +98,8 @@ m_sessionDbLocaleIndex(locale), m_latency(0), m_TutorialsChanged(false), recruiterId(recruiter), isRecruiter(isARecruiter), timeLastWhoCommand(0) { + _warden = NULL; + if (sock) { m_Address = sock->GetRemoteAddress(); @@ -122,6 +126,9 @@ WorldSession::~WorldSession() m_Socket = NULL; } + if (_warden) + delete _warden; + ///- empty incoming packet queue WorldPacket* packet = NULL; while (_recvQueue.next(packet)) @@ -142,6 +149,12 @@ char const* WorldSession::GetPlayerName() const return GetPlayer() ? GetPlayer()->GetName() : ""; } +/// Get player guid if available. Use for logging purposes only +uint32 WorldSession::GetGuidLow() const +{ + return GetPlayer() ? GetPlayer()->GetGUIDLow() : 0; +} + /// Send a packet to the client void WorldSession::SendPacket(WorldPacket const* packet) { @@ -348,6 +361,9 @@ bool WorldSession::Update(uint32 diff, PacketFilter& updater) delete packet; } + if (m_Socket && !m_Socket->IsClosed() && _warden) + _warden->Update(); + ProcessQueryCallbacks(); //check if we are safe to proceed with logout @@ -359,6 +375,9 @@ bool WorldSession::Update(uint32 diff, PacketFilter& updater) if (ShouldLogOut(currTime) && !m_playerLoading) LogoutPlayer(true); + if (m_Socket && GetPlayer() && _warden) + _warden->Update(); + ///- Cleanup socket pointer if need if (m_Socket && m_Socket->IsClosed()) { @@ -1101,3 +1120,18 @@ void WorldSession::ProcessQueryCallbacks() _stableSwapCallback.FreeResult(); } } + +void WorldSession::InitWarden(BigNumber* k, std::string os) +{ + if (os == "Win") + { + _warden = new WardenWin(); + _warden->Init(this, k); + } + else if (os == "OSX") + { + // Disabled as it is causing the client to crash + // _warden = new WardenMac(); + // _warden->Init(this, k); + } +} diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h index db8f984c8..d06579877 100755 --- a/src/server/game/Server/WorldSession.h +++ b/src/server/game/Server/WorldSession.h @@ -29,6 +29,7 @@ #include "DatabaseEnv.h" #include "World.h" #include "WorldPacket.h" +#include "Cryptography/BigNumber.h" struct ItemTemplate; struct AuctionEntry; @@ -46,6 +47,7 @@ class WorldPacket; class WorldSocket; class LoginQueryHolder; class SpellCastTargets; +class Warden; struct AreaTableEntry; struct LfgJoinResultData; struct LfgLockStatus; @@ -242,11 +244,14 @@ class WorldSession uint32 GetAccountId() const { return _accountId; } Player* GetPlayer() const { return _player; } char const* GetPlayerName() const; + uint32 GetGuidLow() const; void SetSecurity(AccountTypes security) { _security = security; } std::string const& GetRemoteAddress() { return m_Address; } void SetPlayer(Player* player); uint8 Expansion() const { return m_expansion; } + void InitWarden(BigNumber* k, std::string os); + /// Session in auth.queue currently void SetInQueue(bool state) { m_inQueue = state; } @@ -488,6 +493,7 @@ class WorldSession void HandleSetActionButtonOpcode(WorldPacket& recvPacket); void HandleGameObjectUseOpcode(WorldPacket& recPacket); + void HandleMeetingStoneInfo(WorldPacket& recPacket); void HandleGameobjectReportUse(WorldPacket& recvPacket); void HandleNameQueryOpcode(WorldPacket& recvPacket); @@ -571,6 +577,7 @@ class WorldSession void HandleActivateTaxiOpcode(WorldPacket& recvPacket); void HandleActivateTaxiExpressOpcode(WorldPacket& recvPacket); void HandleMoveSplineDoneOpcode(WorldPacket& recvPacket); + void SendActivateTaxiReply(ActivateTaxiReply reply); void HandleTabardVendorActivateOpcode(WorldPacket& recvPacket); void HandleBankerActivateOpcode(WorldPacket& recvPacket); @@ -943,6 +950,9 @@ class WorldSession typedef std::list AddonsList; + // Warden + Warden* _warden; // Remains NULL if Warden system is not enabled by config + time_t _logoutTime; bool m_inQueue; // session wait in auth.queue bool m_playerLoading; // code processed in LoginPlayer diff --git a/src/server/game/Server/WorldSocket.cpp b/src/server/game/Server/WorldSocket.cpp index ac6f11660..2c6098fb2 100755 --- a/src/server/game/Server/WorldSocket.cpp +++ b/src/server/game/Server/WorldSocket.cpp @@ -778,11 +778,11 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) //uint8 expansion = 0; LocaleConstant locale; std::string account; - SHA1Hash sha1; + SHA1Hash sha; BigNumber v, s, g, N; WorldPacket packet, SendAddonPacked; - BigNumber K; + BigNumber k; if (sWorld->IsClosed()) { @@ -816,21 +816,9 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) LoginDatabase.EscapeString (safe_account); // No SQL injection, username escaped. - QueryResult result = - LoginDatabase.PQuery ("SELECT " - "id, " //0 - "sessionkey, " //1 - "last_ip, " //2 - "locked, " //3 - "v, " //4 - "s, " //5 - "expansion, " //6 - "mutetime, " //7 - "locale, " //8 - "recruiter " //9 - "FROM account " - "WHERE username = '%s'", - safe_account.c_str()); + // 0 1 2 3 4 5 6 7 8 9 10 + QueryResult result = LoginDatabase.PQuery ("SELECT id, sessionkey, last_ip, locked, v, s, expansion, mutetime, locale, recruiter, os FROM account " + "WHERE username = '%s'", safe_account.c_str()); // Stop if the account is not found if (!result) @@ -882,7 +870,12 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) } id = fields[0].GetUInt32(); - K.SetHexStr (fields[1].GetCString()); + /* + if (security > SEC_ADMINISTRATOR) // prevent invalid security settings in DB + security = SEC_ADMINISTRATOR; + */ + + k.SetHexStr (fields[1].GetCString()); int64 mutetime = fields[7].GetInt64(); //! Negative mutetime indicates amount of seconds to be muted effective on next login - which is now. @@ -903,6 +896,7 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) locale = LOCALE_enUS; uint32 recruiter = fields[9].GetUInt32(); + std::string os = fields[10].GetString(); // Checks gmlevel per Realm result = @@ -954,8 +948,6 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) } // Check that Key and account name are the same on client and server - SHA1Hash sha; - uint32 t = 0; uint32 seed = m_Seed; @@ -963,7 +955,7 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) sha.UpdateData ((uint8 *) & t, 4); sha.UpdateData ((uint8 *) & clientSeed, 4); sha.UpdateData ((uint8 *) & seed, 4); - sha.UpdateBigNumbers (&K, NULL); + sha.UpdateBigNumbers (&k, NULL); sha.Finalize(); if (memcmp (sha.GetDigest(), digest, 20)) @@ -1002,12 +994,16 @@ int WorldSocket::HandleAuthSession (WorldPacket& recvPacket) // NOTE ATM the socket is single-threaded, have this in mind ... ACE_NEW_RETURN (m_Session, WorldSession (id, this, AccountTypes(security), expansion, mutetime, locale, recruiter, isRecruiter), -1); - m_Crypt.Init(&K); + m_Crypt.Init(&k); m_Session->LoadGlobalAccountData(); m_Session->LoadTutorialsData(); m_Session->ReadAddonsInfo(recvPacket); + // Initialize Warden system only if it is enabled by config + if (sWorld->getBoolConfig(CONFIG_WARDEN_ENABLED)) + m_Session->InitWarden(&k, os); + // Sleep this Network thread for uint32 sleepTime = sWorld->getIntConfig(CONFIG_SESSION_ADD_DELAY); ACE_OS::sleep (ACE_Time_Value (0, sleepTime)); diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.cpp b/src/server/game/Spells/Auras/SpellAuraEffects.cpp index a4349dd93..237268871 100755 --- a/src/server/game/Spells/Auras/SpellAuraEffects.cpp +++ b/src/server/game/Spells/Auras/SpellAuraEffects.cpp @@ -374,10 +374,10 @@ pAuraEffectHandler AuraEffectHandler[TOTAL_AURAS]= }; AuraEffect::AuraEffect(Aura* base, uint8 effIndex, int32 *baseAmount, Unit* caster): -m_base(base), m_spellInfo(base->GetSpellInfo()), m_effIndex(effIndex), -m_baseAmount(baseAmount ? *baseAmount : m_spellInfo->Effects[m_effIndex].BasePoints), -m_canBeRecalculated(true), m_spellmod(NULL), m_isPeriodic(false), -m_periodicTimer(0), m_tickNumber(0) +m_base(base), m_spellInfo(base->GetSpellInfo()), +m_baseAmount(baseAmount ? *baseAmount : m_spellInfo->Effects[effIndex].BasePoints), +m_spellmod(NULL), m_periodicTimer(0), m_tickNumber(0), m_effIndex(effIndex), +m_canBeRecalculated(true), m_isPeriodic(false) { CalculatePeriodic(caster, true, false); diff --git a/src/server/game/Spells/Auras/SpellAuraEffects.h b/src/server/game/Spells/Auras/SpellAuraEffects.h index 490f33f46..640799186 100644 --- a/src/server/game/Spells/Auras/SpellAuraEffects.h +++ b/src/server/game/Spells/Auras/SpellAuraEffects.h @@ -104,7 +104,7 @@ class AuraEffect int32 m_periodicTimer; int32 m_amplitude; uint32 m_tickNumber; - + uint8 const m_effIndex; bool m_canBeRecalculated; bool m_isPeriodic; diff --git a/src/server/game/Spells/Auras/SpellAuras.cpp b/src/server/game/Spells/Auras/SpellAuras.cpp index 4bc193b49..5329c1a09 100755 --- a/src/server/game/Spells/Auras/SpellAuras.cpp +++ b/src/server/game/Spells/Auras/SpellAuras.cpp @@ -37,8 +37,8 @@ #include "Vehicle.h" AuraApplication::AuraApplication(Unit* target, Unit* caster, Aura* aura, uint8 effMask): -_target(target), _base(aura), _slot(MAX_AURAS), _flags(AFLAG_NONE), -_effectsToApply(effMask), _removeMode(AURA_REMOVE_NONE), _needClientUpdate(false) +_target(target), _base(aura), _removeMode(AURA_REMOVE_NONE), _slot(MAX_AURAS), +_flags(AFLAG_NONE), _effectsToApply(effMask), _needClientUpdate(false) { ASSERT(GetTarget() && GetBase()); @@ -1840,6 +1840,10 @@ bool Aura::CanStackWith(Aura const* existingAura) const if (!sameCaster) { + // Channeled auras can stack if not forbidden by db or aura type + if (existingAura->GetSpellInfo()->IsChanneled()) + return true; + if (m_spellInfo->AttributesEx3 & SPELL_ATTR3_STACK_FOR_DIFF_CASTERS) return true; @@ -2041,7 +2045,7 @@ void Aura::TriggerProcOnEvent(AuraApplication* aurApp, ProcEventInfo& eventInfo) if (aurApp->HasEffect(i)) // TODO: OnEffectProc hook here (allowing prevention of selected effects) GetEffect(i)->HandleProc(aurApp, eventInfo); - // TODO: AfterEffectProc hook here + // TODO: AfterEffectProc hook here // TODO: AfterProc hook here diff --git a/src/server/game/Spells/Auras/SpellAuras.h b/src/server/game/Spells/Auras/SpellAuras.h index 0af8d1322..2f50d47a7 100755 --- a/src/server/game/Spells/Auras/SpellAuras.h +++ b/src/server/game/Spells/Auras/SpellAuras.h @@ -21,6 +21,7 @@ #include "SpellAuraDefines.h" #include "SpellInfo.h" +#include "Unit.h" class Unit; class SpellInfo; @@ -186,7 +187,7 @@ class Aura bool CanStackWith(Aura const* existingAura) const; // Proc system - // this subsystem is not yet in use - the core of it is functional, but still some research has to be done + // this subsystem is not yet in use - the core of it is functional, but still some research has to be done // and some dependant problems fixed before it can replace old proc system (for example cooldown handling) // currently proc system functionality is implemented in Unit::ProcDamageAndSpell bool IsProcOnCooldown() const; diff --git a/src/server/game/Spells/Spell.cpp b/src/server/game/Spells/Spell.cpp index 48f76515d..633f76487 100755 --- a/src/server/game/Spells/Spell.cpp +++ b/src/server/game/Spells/Spell.cpp @@ -675,8 +675,39 @@ void Spell::InitExplicitTargets(SpellCastTargets const& targets) m_targets.RemoveSrc(); } +void Spell::SelectExplicitTargets() +{ + // here go all explicit target changes made to explicit targets after spell prepare phase is finished + if (Unit* target = m_targets.GetUnitTarget()) + { + // check for explicit target redirection, for Grounding Totem for example + if (m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT_ENEMY + || (m_spellInfo->GetExplicitTargetMask() & TARGET_FLAG_UNIT && !m_spellInfo->IsPositive())) + { + Unit* redirect; + switch (m_spellInfo->DmgClass) + { + case SPELL_DAMAGE_CLASS_MAGIC: + redirect = m_caster->GetMagicHitRedirectTarget(target, m_spellInfo); + break; + case SPELL_DAMAGE_CLASS_MELEE: + case SPELL_DAMAGE_CLASS_RANGED: + redirect = m_caster->GetMeleeHitRedirectTarget(target, m_spellInfo); + break; + default: + redirect = NULL; + break; + } + if (redirect && (redirect != target)) + m_targets.SetUnitTarget(redirect); + } + } +} + void Spell::SelectSpellTargets() { + // select targets for cast phase + SelectExplicitTargets(); uint32 processedTargets = 0; for (uint32 i = 0; i < MAX_SPELL_EFFECTS; ++i) { @@ -2080,16 +2111,7 @@ uint32 Spell::SelectEffectTargets(uint32 i, SpellImplicitTargetInfo const& cur) switch (cur.GetTarget()) { case TARGET_UNIT_TARGET_ENEMY: - if (Unit* magnet = m_caster->SelectMagnetTarget(target, m_spellInfo)) - if (magnet != target) - m_targets.SetUnitTarget(magnet); - pushType = PUSH_CHAIN; - break; case TARGET_UNIT_TARGET_ANY: - if (!m_spellInfo->IsPositive()) - if (Unit* magnet = m_caster->SelectMagnetTarget(target, m_spellInfo)) - if (magnet != target) - m_targets.SetUnitTarget(magnet); pushType = PUSH_CHAIN; break; case TARGET_UNIT_TARGET_CHAINHEAL_ALLY: @@ -2815,13 +2837,13 @@ uint32 Spell::SelectEffectTargets(uint32 i, SpellImplicitTargetInfo const& cur) unitList.remove(m_targets.GetUnitTarget()); Trinity::RandomResizeList(unitList, maxTargets); } + + CallScriptAfterUnitTargetSelectHandlers(unitList, SpellEffIndex(i)); + + for (std::list::iterator itr = unitList.begin(); itr != unitList.end(); ++itr) + AddUnitTarget(*itr, effectMask, false); } - CallScriptAfterUnitTargetSelectHandlers(unitList, SpellEffIndex(i)); - - for (std::list::iterator itr = unitList.begin(); itr != unitList.end(); ++itr) - AddUnitTarget(*itr, effectMask, false); - if (!gobjectList.empty()) { if (uint32 maxTargets = m_spellValue->MaxAffectedTargets) @@ -4652,7 +4674,7 @@ SpellCastResult Spell::CheckCast(bool strict) Unit::AuraEffectList const& blockSpells = m_caster->GetAuraEffectsByType(SPELL_AURA_BLOCK_SPELL_FAMILY); for (Unit::AuraEffectList::const_iterator blockItr = blockSpells.begin(); blockItr != blockSpells.end(); ++blockItr) - if ((*blockItr)->GetMiscValue() == m_spellInfo->SpellFamilyName) + if (uint32((*blockItr)->GetMiscValue()) == m_spellInfo->SpellFamilyName) return SPELL_FAILED_SPELL_UNAVAILABLE; bool reqCombat = true; diff --git a/src/server/game/Spells/Spell.h b/src/server/game/Spells/Spell.h index b20ec345c..583123eb2 100755 --- a/src/server/game/Spells/Spell.h +++ b/src/server/game/Spells/Spell.h @@ -405,6 +405,7 @@ class Spell void WriteAmmoToPacket(WorldPacket* data); void InitExplicitTargets(SpellCastTargets const& targets); + void SelectExplicitTargets(); void SelectSpellTargets(); void SelectEffectTypeImplicitTargets(uint8 effIndex); uint32 SelectEffectTargets(uint32 i, SpellImplicitTargetInfo const& cur); diff --git a/src/server/game/Spells/SpellEffects.cpp b/src/server/game/Spells/SpellEffects.cpp index cdb4d2246..5c49e30f0 100755 --- a/src/server/game/Spells/SpellEffects.cpp +++ b/src/server/game/Spells/SpellEffects.cpp @@ -751,600 +751,6 @@ void Spell::EffectDummy(SpellEffIndex effIndex) // selection by spell family switch (m_spellInfo->SpellFamilyName) { - case SPELLFAMILY_GENERIC: - { - switch (m_spellInfo->Id) - { - case 31225: // Shimmering Vessel (restore creature to life) - { - if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT) - return; - unitTarget->ToCreature()->setDeathState(JUST_ALIVED); - return; - } - case 12162: // Deep wounds - case 12850: // (now good common check for this spells) - case 12868: - { - if (!unitTarget) - return; - - // apply percent damage mods - damage = m_caster->SpellDamageBonus(unitTarget, m_spellInfo, damage, SPELL_DIRECT_DAMAGE); - - switch (m_spellInfo->Id) - { - case 12162: ApplyPctN(damage, 16); break; // Rank 1 - case 12850: ApplyPctN(damage, 32); break; // Rank 2 - case 12868: ApplyPctN(damage, 48); break; // Rank 3 - default: - sLog->outError("Spell::EffectDummy: Spell %u not handled in DW", m_spellInfo->Id); - return; - } - - SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(12721); - uint32 ticks = spellInfo->GetDuration() / spellInfo->Effects[EFFECT_0].Amplitude; - - // Add remaining ticks to damage done - if (AuraEffect const* aurEff = unitTarget->GetAuraEffect(12721, EFFECT_0, m_caster->GetGUID())) - damage += aurEff->GetAmount() * (ticks - aurEff->GetTickNumber()); - - damage = damage / ticks; - m_caster->CastCustomSpell(unitTarget, 12721, &damage, NULL, NULL, true); - return; - } - case 13567: // Dummy Trigger - { - // can be used for different aura triggering, so select by aura - if (!m_triggeredByAuraSpell || !unitTarget) - return; - - switch (m_triggeredByAuraSpell->Id) - { - case 26467: // Persistent Shield - m_caster->CastCustomSpell(unitTarget, 26470, &damage, NULL, NULL, true); - break; - default: - sLog->outError("EffectDummy: Non-handled case for spell 13567 for triggered aura %u", m_triggeredByAuraSpell->Id); - break; - } - return; - } - case 17251: // Spirit Healer Res - { - if (!unitTarget || !m_originalCaster) - return; - - if (m_originalCaster->GetTypeId() == TYPEID_PLAYER) - { - WorldPacket data(SMSG_SPIRIT_HEALER_CONFIRM, 8); - data << uint64(unitTarget->GetGUID()); - m_originalCaster->ToPlayer()->GetSession()->SendPacket(&data); - } - return; - } - case 23019: // Crystal Prison Dummy DND - { - if (!unitTarget || !unitTarget->isAlive() || unitTarget->GetTypeId() != TYPEID_UNIT || unitTarget->ToCreature()->isPet()) - return; - - Creature* creatureTarget = unitTarget->ToCreature(); - - m_caster->SummonGameObject(179644, creatureTarget->GetPositionX(), creatureTarget->GetPositionY(), creatureTarget->GetPositionZ(), creatureTarget->GetOrientation(), 0, 0, 0, 0, uint32(creatureTarget->GetRespawnTime()-time(NULL))); - sLog->outDebug(LOG_FILTER_SPELLS_AURAS, "SummonGameObject at SpellEfects.cpp EffectDummy for Spell 23019"); - - creatureTarget->DespawnOrUnsummon(); - - return; - } - case 23448: // Transporter Arrival - Ultrasafe Transporter: Gadgetzan - backfires - { - int32 r = irand(0, 119); - if (r < 20) // Transporter Malfunction - 1/6 polymorph - m_caster->CastSpell(m_caster, 23444, true); - else if (r < 100) // Evil Twin - 4/6 evil twin - m_caster->CastSpell(m_caster, 23445, true); - else // Transporter Malfunction - 1/6 miss the target - m_caster->CastSpell(m_caster, 36902, true); - return; - } - case 23453: // Gnomish Transporter - Ultrasafe Transporter: Gadgetzan - if (roll_chance_i(50)) // Gadgetzan Transporter - success - m_caster->CastSpell(m_caster, 23441, true); - else // Gadgetzan Transporter Failure - failure - m_caster->CastSpell(m_caster, 23446, true); - return; - case 25860: // Reindeer Transformation - { - if (!m_caster->HasAuraType(SPELL_AURA_MOUNTED)) - return; - - float flyspeed = m_caster->GetSpeedRate(MOVE_FLIGHT); - float speed = m_caster->GetSpeedRate(MOVE_RUN); - - m_caster->RemoveAurasByType(SPELL_AURA_MOUNTED); - - //5 different spells used depending on mounted speed and if mount can fly or not - if (flyspeed >= 4.1f) - // Flying Reindeer - m_caster->CastSpell(m_caster, 44827, true); //310% flying Reindeer - else if (flyspeed >= 3.8f) - // Flying Reindeer - m_caster->CastSpell(m_caster, 44825, true); //280% flying Reindeer - else if (flyspeed >= 1.6f) - // Flying Reindeer - m_caster->CastSpell(m_caster, 44824, true); //60% flying Reindeer - else if (speed >= 2.0f) - // Reindeer - m_caster->CastSpell(m_caster, 25859, true); //100% ground Reindeer - else - // Reindeer - m_caster->CastSpell(m_caster, 25858, true); //60% ground Reindeer - - return; - } - case 26074: // Holiday Cheer - // implemented at client side - return; - // Polarity Shift - case 28089: - if (unitTarget) - unitTarget->CastSpell(unitTarget, roll_chance_i(50) ? 28059 : 28084, true, NULL, NULL, m_caster->GetGUID()); - break; - // Polarity Shift - case 39096: - if (unitTarget) - unitTarget->CastSpell(unitTarget, roll_chance_i(50) ? 39088 : 39091, true, NULL, NULL, m_caster->GetGUID()); - break; - case 29200: // Purify Helboar Meat - { - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - - spell_id = roll_chance_i(50) - ? 29277 // Summon Purified Helboar Meat - : 29278; // Summon Toxic Helboar Meat - - m_caster->CastSpell(m_caster, spell_id, true, NULL); - return; - } - case 29858: // Soulshatter - if (unitTarget && unitTarget->CanHaveThreatList() - && unitTarget->getThreatManager().getThreat(m_caster) > 0.0f) - m_caster->CastSpell(unitTarget, 32835, true); - return; - case 30458: // Nigh Invulnerability - if (!m_CastItem) return; - if (roll_chance_i(86)) // Nigh-Invulnerability - success - m_caster->CastSpell(m_caster, 30456, true, m_CastItem); - else // Complete Vulnerability - backfire in 14% casts - m_caster->CastSpell(m_caster, 30457, true, m_CastItem); - return; - case 30507: // Poultryizer - if (!m_CastItem) return; - if (roll_chance_i(80)) // Poultryized! - success - m_caster->CastSpell(unitTarget, 30501, true, m_CastItem); - else // Poultryized! - backfire 20% - m_caster->CastSpell(unitTarget, 30504, true, m_CastItem); - return; - case 35745: // Socrethar's Stone - { - switch (m_caster->GetAreaId()) - { - case 3900: - spell_id = 35743; - break; // Socrethar Portal - case 3742: - spell_id = 35744; - break; // Socrethar Portal - default: - return; - } - - m_caster->CastSpell(m_caster, spell_id, true); - return; - } - case 37674: // Chaos Blast - { - if (!unitTarget) - return; - - int32 basepoints0 = 100; - m_caster->CastCustomSpell(unitTarget, 37675, &basepoints0, NULL, NULL, true); - return; - } - // Wrath of the Astromancer - case 42784: - { - uint32 count = 0; - for (std::list::iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) - if (ihit->effectMask & (1<GetSpellInfo(42784); - - // now deal the damage - for (std::list::iterator ihit= m_UniqueTargetInfo.begin(); ihit != m_UniqueTargetInfo.end(); ++ihit) - if (ihit->effectMask & (1<targetGUID)) - m_caster->DealDamage(casttarget, damage, NULL, SPELL_DIRECT_DAMAGE, SPELL_SCHOOL_MASK_ARCANE, spellInfo, false); - } - - return; - } - // Demon Broiled Surprise - case 43723: - { - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - - Player* player = (Player*)m_caster; - - if (player && player->GetQuestStatus(11379) == QUEST_STATUS_INCOMPLETE) - { - Creature* creature = player->FindNearestCreature(19973, 10, false); - if (!creature) - { - SendCastResult(SPELL_FAILED_NOT_HERE); - return; - } - - player->CastSpell(player, 43753, false); - } - return; - } - case 44875: // Complete Raptor Capture - { - if (!unitTarget || unitTarget->GetTypeId() != TYPEID_UNIT) - return; - - unitTarget->ToCreature()->DespawnOrUnsummon(); - - //cast spell Raptor Capture Credit - m_caster->CastSpell(m_caster, 42337, true, NULL); - return; - } - case 47170: // Impale Leviroth - { - if (!unitTarget || (unitTarget->GetEntry() != 26452 && unitTarget->HealthAbovePct(95))) - return; - - m_caster->DealDamage(unitTarget, unitTarget->CountPctFromMaxHealth(93)); - return; - } - case 49357: // Brewfest Mount Transformation - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - if (!m_caster->HasAuraType(SPELL_AURA_MOUNTED)) - return; - m_caster->RemoveAurasByType(SPELL_AURA_MOUNTED); - // Ram for Alliance, Kodo for Horde - if (m_caster->ToPlayer()->GetTeam() == ALLIANCE) - { - if (m_caster->GetSpeedRate(MOVE_RUN) >= 2.0f) - // 100% Ram - m_caster->CastSpell(m_caster, 43900, true); - else - // 60% Ram - m_caster->CastSpell(m_caster, 43899, true); - } - else - { - if (m_caster->ToPlayer()->GetSpeedRate(MOVE_RUN) >= 2.0f) - // 100% Kodo - m_caster->CastSpell(m_caster, 49379, true); - else - // 60% Kodo - m_caster->CastSpell(m_caster, 49378, true); - } - return; - case 52845: // Brewfest Mount Transformation (Faction Swap) - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - if (!m_caster->HasAuraType(SPELL_AURA_MOUNTED)) - return; - m_caster->RemoveAurasByType(SPELL_AURA_MOUNTED); - // Ram for Horde, Kodo for Alliance - if (m_caster->ToPlayer()->GetTeam() == HORDE) - { - if (m_caster->GetSpeedRate(MOVE_RUN) >= 2.0f) - // 100% Ram - m_caster->CastSpell(m_caster, 43900, true); - else - // 60% Ram - m_caster->CastSpell(m_caster, 43899, true); - } - else - { - if (m_caster->ToPlayer()->GetSpeedRate(MOVE_RUN) >= 2.0f) - // 100% Kodo - m_caster->CastSpell(m_caster, 49379, true); - else - // 60% Kodo - m_caster->CastSpell(m_caster, 49378, true); - } - return; - case 55004: // Nitro Boosts - if (!m_CastItem) - return; - if (roll_chance_i(95)) // Nitro Boosts - success - m_caster->CastSpell(m_caster, 54861, true, m_CastItem); - else // Knocked Up - backfire 5% - m_caster->CastSpell(m_caster, 46014, true, m_CastItem); - return; - case 50243: // Teach Language - { - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - - // spell has a 1/3 chance to trigger one of the below - if (roll_chance_i(66)) - return; - if (m_caster->ToPlayer()->GetTeam() == ALLIANCE) - { - // 1000001 - gnomish binary - m_caster->CastSpell(m_caster, 50242, true); - } - else - { - // 01001000 - goblin binary - m_caster->CastSpell(m_caster, 50246, true); - } - - return; - } - case 51582: //Rocket Boots Engaged (Rocket Boots Xtreme and Rocket Boots Xtreme Lite) - { - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - - if (Battleground* bg = m_caster->ToPlayer()->GetBattleground()) - bg->EventPlayerDroppedFlag(m_caster->ToPlayer()); - - m_caster->CastSpell(m_caster, 30452, true, NULL); - return; - } - case 52759: // Ancestral Awakening - if (!unitTarget) - return; - m_caster->CastCustomSpell(unitTarget, 52752, &damage, NULL, NULL, true); - return; - case 54171: // Divine Storm - { - if (m_UniqueTargetInfo.size()) - { - int32 heal = damage / m_UniqueTargetInfo.size(); - m_caster->CastCustomSpell(unitTarget, 54172, &heal, NULL, NULL, true); - } - return; - } - case 58418: // Portal to Orgrimmar - case 58420: // Portal to Stormwind - return; // implemented in EffectScript[0] - case 62324: // Throw Passenger - { - if (m_targets.HasTraj()) - { - if (Vehicle* vehicle = m_caster->GetVehicleKit()) - if (Unit* passenger = vehicle->GetPassenger(damage - 1)) - { - std::list unitList; - // use 99 because it is 3d search - SearchAreaTarget(unitList, 99, PUSH_DST_CENTER, SPELL_TARGETS_ENTRY, 33114); - float minDist = 99 * 99; - Unit* target = NULL; - for (std::list::iterator itr = unitList.begin(); itr != unitList.end(); ++itr) - { - if (Vehicle* seat = (*itr)->GetVehicleKit()) - if (!seat->GetPassenger(0)) - if (Unit* device = seat->GetPassenger(2)) - if (!device->GetCurrentSpell(CURRENT_CHANNELED_SPELL)) - { - float dist = (*itr)->GetExactDistSq(m_targets.GetDst()); - if (dist < minDist) - { - minDist = dist; - target = (*itr); - } - } - } - if (target && target->IsWithinDist2d(m_targets.GetDst(), m_spellInfo->Effects[effIndex].CalcRadius() * 2)) // now we use *2 because the location of the seat is not correct - passenger->EnterVehicle(target, 0); - else - { - passenger->ExitVehicle(); - float x, y, z; - m_targets.GetDst()->GetPosition(x, y, z); - passenger->GetMotionMaster()->MoveJump(x, y, z, m_targets.GetSpeedXY(), m_targets.GetSpeedZ()); - } - } - } - return; - } - case 64385: // Unusual Compass - { - m_caster->SetOrientation(float(urand(0, 62832)) / 10000.0f); - WorldPacket data; - m_caster->BuildHeartBeatMsg(&data); - m_caster->SendMessageToSet(&data, true); - return; - } - case 53808: // Pygmy Oil - { - Aura* pAura = m_caster->GetAura(53806); - if (pAura) - pAura->RefreshDuration(); - else - { - pAura = m_caster->GetAura(53805); - if (!pAura || pAura->GetStackAmount() < 5 || !roll_chance_i(50)) - m_caster->CastSpell(m_caster, 53805, true); - else - { - pAura->Remove(); - m_caster->CastSpell(m_caster, 53806, true); - } - } - return; - } - case 54577: // U.D.E.D. - { - if (unitTarget->GetEntry() != 29402) - return; - - m_caster->SummonGameObject(192693, unitTarget->GetPositionX(), unitTarget->GetPositionY(), - unitTarget->GetPositionZ(), unitTarget->GetOrientation(), 0, 0, 0, 0, 100); - - for (uint8 i = 0; i < 4; ++i) - m_caster->SummonGameObject(191567, float(unitTarget->GetPositionX() + irand(-7, 7)), - float(unitTarget->GetPositionY() + irand(-7, 7)), unitTarget->GetPositionZ(), unitTarget->GetOrientation(), - 0, 0, 0, 0, 100); - - unitTarget->Kill(unitTarget); - return; - } - case 51961: // Captured Chicken Cover - Quest 12702 & 12532 - { - if (m_caster->GetTypeId() != TYPEID_PLAYER - || !unitTarget->HasAura(51959) - || !(m_caster->ToPlayer()->GetQuestStatus(12702) == QUEST_STATUS_INCOMPLETE || m_caster->ToPlayer()->GetQuestStatus(12532) == QUEST_STATUS_INCOMPLETE)) - return; - - m_caster->CastSpell(m_caster, 51037, true); - unitTarget->Kill(unitTarget); - return; - } - } - - break; - } - case SPELLFAMILY_WARRIOR: - // Charge - if (m_spellInfo->SpellFamilyFlags & SPELLFAMILYFLAG_WARRIOR_CHARGE && m_spellInfo->SpellVisual[0] == 867) - { - int32 chargeBasePoints0 = damage; - m_caster->CastCustomSpell(m_caster, 34846, &chargeBasePoints0, NULL, NULL, true); - - //Juggernaut crit bonus - if (m_caster->HasAura(64976)) - m_caster->CastSpell(m_caster, 65156, true); - return; - } - // Slam - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_WARRIOR_SLAM && m_spellInfo->SpellIconID == 559) - { - int32 bp0 = damage; - m_caster->CastCustomSpell(unitTarget, 50783, &bp0, NULL, NULL, true, 0); - return; - } - // Execute - if (m_spellInfo->SpellFamilyFlags[EFFECT_0] & SPELLFAMILYFLAG_WARRIOR_EXECUTE) - { - if (!unitTarget) - return; - - spell_id = 20647; - - int32 rageUsed = std::min(300 - m_powerCost, m_caster->GetPower(POWER_RAGE)); - int32 newRage = std::max(0, m_caster->GetPower(POWER_RAGE) - rageUsed); - - // Sudden Death rage save - if (AuraEffect* aurEff = m_caster->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_GENERIC, 1989, EFFECT_0)) - { - int32 ragesave = aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue() * 10; - newRage = std::max(newRage, ragesave); - } - - m_caster->SetPower(POWER_RAGE, uint32(newRage)); - - // Glyph of Execution bonus - if (AuraEffect* aurEff = m_caster->GetAuraEffect(58367, EFFECT_0)) - rageUsed += aurEff->GetAmount() * 10; - - bp = damage + int32(rageUsed * m_spellInfo->Effects[effIndex].DamageMultiplier + m_caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.2f); - break; - } - // Concussion Blow - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_WARRIOR_CONCUSSION_BLOW) - { - m_damage += CalculatePctF(damage, m_caster->GetTotalAttackPowerValue(BASE_ATTACK)); - return; - } - switch (m_spellInfo->Id) - { - // Bloodthirst - case 23881: - { - m_caster->CastCustomSpell(unitTarget, 23885, &damage, NULL, NULL, true, NULL); - return; - } - } - break; - case SPELLFAMILY_WARLOCK: - // Life Tap - if ((m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_WARLOCK_LIFETAP) && m_caster->ToPlayer()) - { - float spFactor = 0.0f; - switch (m_spellInfo->Id) - { - case 11689: spFactor = 0.2f; break; - case 27222: - case 57946: spFactor = 0.5f; break; - } - int32 damage = int32(m_spellInfo->Effects[EFFECT_0].CalcValue() + (6.3875 * m_spellInfo->BaseLevel)); - int32 mana = int32(damage + (m_caster->ToPlayer()->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+SPELL_SCHOOL_SHADOW) * spFactor)); - - if (unitTarget && (int32(unitTarget->GetHealth()) > damage)) - { - // Shouldn't Appear in Combat Log - unitTarget->ModifyHealth(-damage); - - // Improved Life Tap mod - if (AuraEffect const* aurEff = m_caster->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, 208, 0)) - AddPctN(mana, aurEff->GetAmount()); - - m_caster->CastCustomSpell(unitTarget, 31818, &mana, NULL, NULL, false); - - // Mana Feed - int32 manaFeedVal = 0; - if (AuraEffect const* aurEff = m_caster->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_WARLOCK, 1982, 0)) - manaFeedVal = aurEff->GetAmount(); - - if (manaFeedVal > 0) - { - ApplyPctN(manaFeedVal, mana); - m_caster->CastCustomSpell(m_caster, 32553, &manaFeedVal, NULL, NULL, true, NULL); - } - } - else - SendCastResult(SPELL_FAILED_FIZZLE); - return; - } - break; - case SPELLFAMILY_DRUID: - // Starfall - if (m_spellInfo->SpellFamilyFlags[2] & SPELLFAMILYFLAG2_DRUID_STARFALL) - { - //Shapeshifting into an animal form or mounting cancels the effect. - if (m_caster->GetCreatureType() == CREATURE_TYPE_BEAST || m_caster->IsMounted()) - { - if (m_triggeredByAuraSpell) - m_caster->RemoveAurasDueToSpell(m_triggeredByAuraSpell->Id); - return; - } - - //Any effect which causes you to lose control of your character will supress the starfall effect. - if (m_caster->HasUnitState(UNIT_STATE_CONTROLLED)) - return; - - m_caster->CastSpell(unitTarget, damage, true); - return; - } - break; case SPELLFAMILY_PALADIN: switch (m_spellInfo->Id) { @@ -1378,128 +784,40 @@ void Spell::EffectDummy(SpellEffIndex effIndex) } } break; - case SPELLFAMILY_SHAMAN: - // Cleansing Totem Pulse - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_SHAMAN_TOTEM_EFFECTS && m_spellInfo->SpellIconID == 1673) - { - int32 bp1 = 1; - // Cleansing Totem Effect - if (unitTarget) - m_caster->CastCustomSpell(unitTarget, 52025, NULL, &bp1, NULL, true, NULL, NULL, m_originalCasterGUID); - return; - } - // Healing Stream Totem - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_SHAMAN_HEALING_STREAM) - { - if (!unitTarget) - return; - if (Unit* owner = m_caster->GetOwner()) - { - if (m_triggeredByAuraSpell) - damage = int32(owner->SpellHealingBonus(unitTarget, m_triggeredByAuraSpell, damage, HEAL)); - - // Restorative Totems - if (AuraEffect* dummy = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 338, 1)) - AddPctN(damage, dummy->GetAmount()); - - // Glyph of Healing Stream Totem - if (AuraEffect const* aurEff = owner->GetAuraEffect(55456, EFFECT_0)) - AddPctN(damage, aurEff->GetAmount()); - } - m_caster->CastCustomSpell(unitTarget, 52042, &damage, 0, 0, true, 0, 0, m_originalCasterGUID); - return; - } - // Mana Spring Totem - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_SHAMAN_MANA_SPRING) - { - if (!unitTarget || unitTarget->getPowerType() != POWER_MANA) - return; - m_caster->CastCustomSpell(unitTarget, 52032, &damage, 0, 0, true, 0, 0, m_originalCasterGUID); - return; - } - // Lava Lash - if (m_spellInfo->SpellFamilyFlags[2] & SPELLFAMILYFLAG2_SHAMAN_LAVA_LASH) - { - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; - - if (m_caster->ToPlayer()->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND)) - { - // Damage is increased by 25% if your off-hand weapon is enchanted with Flametongue. - if (m_caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0x200000, 0, 0)) - AddPctN(m_damage, damage); - } - return; - } - break; case SPELLFAMILY_DEATHKNIGHT: - // Death strike - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_DK_DEATH_STRIKE) - { - uint32 count = unitTarget->GetDiseasesByCaster(m_caster->GetGUID()); - bp = int32(count * m_caster->CountPctFromMaxHealth(int32(m_spellInfo->Effects[EFFECT_0].DamageMultiplier))); - // Improved Death Strike - if (AuraEffect const* aurEff = m_caster->GetAuraEffect(SPELL_AURA_ADD_PCT_MODIFIER, SPELLFAMILY_DEATHKNIGHT, 2751, 0)) - AddPctN(bp, m_caster->CalculateSpellDamage(m_caster, aurEff->GetSpellInfo(), 2)); - m_caster->CastCustomSpell(m_caster, 45470, &bp, NULL, NULL, false); - return; - } - // Death Coil - if (m_spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_DK_DEATH_COIL) - { - if (m_caster->IsFriendlyTo(unitTarget)) - { - bp = int32(damage * 1.5f); - m_caster->CastCustomSpell(unitTarget, 47633, &bp, NULL, NULL, true); - } - else - { - bp = damage; - m_caster->CastCustomSpell(unitTarget, 47632, &bp, NULL, NULL, true); - } - return; - } switch (m_spellInfo->Id) { - case 49560: // Death Grip - Position pos; - GetSummonPosition(effIndex, pos); - if (Unit* unit = unitTarget->GetVehicleBase()) // what is this for? - unit->CastSpell(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), damage, true); - else if (!unitTarget->HasAuraType(SPELL_AURA_DEFLECT_SPELLS)) // Deterrence - unitTarget->CastSpell(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), damage, true); - return; - case 46584: // Raise Dead - if (m_caster->GetTypeId() != TYPEID_PLAYER) - return; + case 46584: // Raise Dead + if (m_caster->GetTypeId() != TYPEID_PLAYER) + return; - // Do we have talent Master of Ghouls? - if (m_caster->HasAura(52143)) - // summon as pet - bp = 52150; - else - // or guardian - bp = 46585; + // Do we have talent Master of Ghouls? + if (m_caster->HasAura(52143)) + // summon as pet + bp = 52150; + else + // or guardian + bp = 46585; - if (m_targets.HasDst()) - targets.SetDst(*m_targets.GetDst()); - else - { - targets.SetDst(*m_caster); - // Corpse not found - take reagents (only not triggered cast can take them) - triggered = false; - } - // Remove cooldown - summon spellls have category - m_caster->ToPlayer()->RemoveSpellCooldown(m_spellInfo->Id, true); - spell_id = 48289; - break; - // Raise dead - take reagents and trigger summon spells - case 48289: - if (m_targets.HasDst()) - targets.SetDst(*m_targets.GetDst()); + if (m_targets.HasDst()) + targets.SetDst(*m_targets.GetDst()); + else + { + targets.SetDst(*m_caster); + // Corpse not found - take reagents (only not triggered cast can take them) + triggered = false; + } + // Remove cooldown - summon spellls have category + m_caster->ToPlayer()->RemoveSpellCooldown(m_spellInfo->Id, true); + spell_id = 48289; + break; + // Raise dead - take reagents and trigger summon spells + case 48289: + if (m_targets.HasDst()) + targets.SetDst(*m_targets.GetDst()); - spell_id = CalculateDamage(0, NULL); - break; + spell_id = CalculateDamage(0, NULL); + break; } break; } @@ -3064,6 +2382,9 @@ void Spell::EffectSummonType(SpellEffIndex effIndex) case 629: case 181: case 715: + case 1562: + case 833: + case 1161: numSummons = (damage > 0) ? damage : 1; break; default: diff --git a/src/server/game/Spells/SpellScript.cpp b/src/server/game/Spells/SpellScript.cpp index 8a58ce3c5..14dd32a71 100755 --- a/src/server/game/Spells/SpellScript.cpp +++ b/src/server/game/Spells/SpellScript.cpp @@ -468,6 +468,16 @@ void SpellScript::PreventHitAura() m_spell->m_spellAura->Remove(); } +void SpellScript::GetSummonPosition(uint32 i, Position &pos, float radius = 0.0f, uint32 count = 0) +{ + m_spell->GetSummonPosition(i, pos, radius, count); +} + +void SpellScript::SearchAreaTarget(std::list &TagUnitMap, float radius, SpellNotifyPushType type, SpellTargets TargetType, uint32 entry) +{ + m_spell->SearchAreaTarget(TagUnitMap, radius, type, TargetType, entry); +} + void SpellScript::PreventHitEffect(SpellEffIndex effIndex) { if (!IsInHitPhase() && !IsInEffectHook()) diff --git a/src/server/game/Spells/SpellScript.h b/src/server/game/Spells/SpellScript.h index 945a62674..09b9eaebd 100755 --- a/src/server/game/Spells/SpellScript.h +++ b/src/server/game/Spells/SpellScript.h @@ -21,6 +21,7 @@ #include "Util.h" #include "SharedDefines.h" #include "SpellAuraDefines.h" +#include "Spell.h" #include class Unit; @@ -333,7 +334,9 @@ class SpellScript : public _SpellScript int32 GetHitHeal(); void SetHitHeal(int32 heal); void PreventHitHeal() { SetHitHeal(0); } - + Spell* GetSpell() { return m_spell; } + void GetSummonPosition(uint32 i, Position &pos, float radius, uint32 count); + void SearchAreaTarget(std::list &TagUnitMap, float radius, SpellNotifyPushType type, SpellTargets TargetType, uint32 entry); // returns current spell hit target aura Aura* GetHitAura(); // prevents applying aura on current spell hit target diff --git a/src/server/game/Warden/Modules/WardenModuleMac.h b/src/server/game/Warden/Modules/WardenModuleMac.h new file mode 100644 index 000000000..46011c5bc --- /dev/null +++ b/src/server/game/Warden/Modules/WardenModuleMac.h @@ -0,0 +1,614 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDEN_MODULE_MAC_H +#define _WARDEN_MODULE_MAC_H + +uint8 Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data[9318] = +{ + 0x07, 0x0C, 0x44, 0xCD, 0xC9, 0xFB, 0x99, 0xBC, 0x7C, 0x77, 0xDC, 0xE8, 0x8D, 0x07, 0xBE, 0x55, + 0x37, 0x5C, 0x84, 0x10, 0x23, 0xE1, 0x36, 0x5B, 0xF1, 0xBC, 0x60, 0xF3, 0x68, 0xBA, 0x60, 0x69, + 0xDF, 0x48, 0x54, 0xFF, 0x49, 0x1F, 0xA6, 0x28, 0x08, 0x5A, 0x77, 0xFE, 0x4C, 0x3A, 0x9A, 0x28, + 0xA5, 0x9E, 0x01, 0x93, 0x05, 0xE4, 0xCD, 0x26, 0x41, 0xD7, 0xD6, 0x73, 0x81, 0xFD, 0xF5, 0xDB, + 0xA5, 0xF7, 0xF9, 0x1D, 0xFE, 0xF4, 0x06, 0x7C, 0xD0, 0xF8, 0x5A, 0xE8, 0x11, 0xFF, 0xE5, 0xF9, + 0x54, 0x49, 0xF7, 0xF0, 0xF8, 0x66, 0x22, 0x97, 0xA4, 0xB2, 0x86, 0xFE, 0xA6, 0x3A, 0x7F, 0x3B, + 0xF6, 0x47, 0xB4, 0x14, 0xEB, 0x9E, 0xC9, 0xEA, 0x0B, 0x41, 0xB4, 0x5B, 0xC2, 0xFB, 0x63, 0x1C, + 0x46, 0xC4, 0xAB, 0x3F, 0x30, 0x70, 0x7F, 0x35, 0xA3, 0xD2, 0x1A, 0xDE, 0x36, 0x79, 0x02, 0x05, + 0x0E, 0x47, 0xFF, 0xDF, 0x1F, 0xB7, 0xE0, 0x11, 0x7F, 0xB8, 0x43, 0x8C, 0x46, 0xF0, 0x4D, 0x39, + 0x83, 0x7C, 0x44, 0xE7, 0xD0, 0x02, 0x54, 0xAB, 0x84, 0xB3, 0x64, 0xCA, 0xD2, 0xB6, 0xF5, 0xDC, + 0x06, 0x2B, 0x39, 0x27, 0x5B, 0x18, 0x82, 0xC4, 0xD6, 0x95, 0xB1, 0xDE, 0x2F, 0x0C, 0xAD, 0x96, + 0x12, 0xBF, 0x82, 0x0B, 0x78, 0x77, 0x7B, 0x42, 0x96, 0x87, 0xF6, 0x7B, 0xE2, 0x0B, 0x36, 0x2C, + 0x34, 0xCD, 0xFA, 0x01, 0x60, 0x3F, 0x52, 0x9B, 0xAB, 0xAC, 0x25, 0xF1, 0xDE, 0xD0, 0x61, 0x12, + 0x21, 0xF2, 0xDE, 0xB7, 0xA4, 0x5F, 0x5F, 0xA2, 0xA7, 0x31, 0xAC, 0x2D, 0xA3, 0x42, 0xCF, 0x73, + 0x88, 0x53, 0x02, 0x60, 0x9A, 0x11, 0xCB, 0xDF, 0xB9, 0x97, 0x10, 0x3F, 0xBD, 0xF6, 0x14, 0x38, + 0x1D, 0xAD, 0xC5, 0x22, 0x99, 0x40, 0x1C, 0xA3, 0x3D, 0x2E, 0x2E, 0x93, 0x70, 0xE4, 0x5B, 0x3E, + 0x9E, 0xDC, 0x6E, 0x4D, 0xC2, 0xDA, 0x2D, 0x54, 0x4A, 0xDF, 0xFD, 0x30, 0x4C, 0xAF, 0x5D, 0xDE, + 0xEB, 0xFF, 0xCF, 0xE3, 0x9A, 0x3C, 0x4F, 0xB3, 0x7D, 0x61, 0xEB, 0x66, 0xD8, 0xBC, 0x12, 0xC1, + 0xD4, 0x66, 0xBD, 0x89, 0x64, 0x8E, 0x68, 0xA6, 0xD4, 0xDC, 0xA4, 0x00, 0x84, 0x9A, 0x53, 0x1E, + 0x4D, 0x1B, 0x84, 0x19, 0xF8, 0x0A, 0x85, 0x96, 0x99, 0x64, 0xEB, 0xAE, 0x11, 0xFB, 0xC8, 0xBB, + 0xC0, 0x8E, 0x5B, 0x8E, 0xE3, 0x95, 0x50, 0x8A, 0xD4, 0x68, 0x0A, 0x11, 0xED, 0xC2, 0x8F, 0x87, + 0xA7, 0x3F, 0xB4, 0x99, 0xDF, 0x37, 0xF6, 0x4F, 0x32, 0x4E, 0x0B, 0x99, 0x35, 0xD0, 0x1E, 0x40, + 0x00, 0x8C, 0x3C, 0xCE, 0xC8, 0xE3, 0x89, 0x7B, 0x09, 0xA3, 0xA7, 0x35, 0x5B, 0x2B, 0x82, 0x98, + 0xC3, 0xEE, 0xD8, 0xAF, 0x59, 0x0C, 0xFB, 0x28, 0x57, 0x21, 0x79, 0x33, 0xDC, 0x3E, 0xD7, 0x66, + 0x02, 0x47, 0xC1, 0x1E, 0xB8, 0x85, 0x28, 0x1A, 0x1C, 0x5C, 0xA2, 0x11, 0x18, 0x9C, 0xB7, 0x54, + 0x4B, 0x97, 0x6D, 0x90, 0x93, 0x31, 0x6C, 0x07, 0x3B, 0xE9, 0x35, 0xD7, 0x3B, 0x59, 0x7A, 0x5B, + 0xEC, 0xE1, 0x63, 0xC4, 0xB6, 0x1A, 0x97, 0xEE, 0x1A, 0xD0, 0xF5, 0xF6, 0xBF, 0x10, 0x55, 0xCB, + 0x7F, 0xF7, 0x3C, 0x2D, 0x7D, 0xDF, 0x5C, 0xE1, 0x84, 0xF1, 0xD5, 0x87, 0x05, 0xEE, 0x94, 0xE3, + 0x55, 0xF3, 0x8B, 0xD1, 0x4B, 0xBF, 0x7E, 0x93, 0xEB, 0xAB, 0x09, 0x36, 0x3E, 0x8D, 0xA6, 0x90, + 0xC5, 0x2E, 0x0A, 0xF4, 0x2B, 0x9E, 0xBC, 0xDA, 0xC1, 0x3A, 0x77, 0x96, 0x8E, 0xA2, 0x28, 0x53, + 0x0B, 0x37, 0xEC, 0x3F, 0xA6, 0xED, 0xF7, 0x32, 0x3A, 0x7D, 0xE5, 0x64, 0x1C, 0xAE, 0x6B, 0xB4, + 0x08, 0xDA, 0xCD, 0x3E, 0x32, 0xC7, 0x0F, 0xDF, 0xDE, 0x9D, 0x4D, 0x20, 0xE0, 0x71, 0x7C, 0xB7, + 0xAF, 0x87, 0x99, 0x4B, 0xCC, 0x3B, 0xFB, 0x26, 0xAA, 0x01, 0xF3, 0x77, 0x01, 0x7E, 0x8C, 0x0D, + 0x09, 0x9D, 0x40, 0xFD, 0x3D, 0xA1, 0xEA, 0x53, 0x99, 0x68, 0x87, 0xE2, 0xCA, 0x1B, 0x1F, 0x45, + 0x83, 0xF1, 0x74, 0xBB, 0x65, 0x49, 0x46, 0xD2, 0x43, 0xDA, 0xE1, 0x4D, 0x29, 0x3A, 0x41, 0x81, + 0xF6, 0x46, 0x03, 0x43, 0x19, 0xBA, 0x2F, 0x79, 0xF0, 0xA3, 0xB4, 0x92, 0x08, 0x74, 0xE0, 0x61, + 0x0F, 0x26, 0xEF, 0xDE, 0x3B, 0x52, 0x9F, 0xB4, 0x06, 0x5D, 0xC6, 0xBC, 0x3C, 0xA5, 0x86, 0x7C, + 0x35, 0x21, 0xF7, 0x05, 0xCD, 0x05, 0x15, 0x31, 0xE0, 0xC0, 0xF6, 0x12, 0x70, 0x56, 0xF9, 0x25, + 0xB7, 0x91, 0x34, 0x85, 0x5D, 0xE9, 0x5D, 0xB8, 0x4F, 0x4C, 0xFB, 0xB5, 0xB6, 0x2F, 0xAE, 0xA3, + 0x2A, 0x99, 0x25, 0x4D, 0x17, 0x41, 0x47, 0xC3, 0xF5, 0x04, 0x52, 0xCC, 0xDE, 0x4E, 0xA3, 0x42, + 0x30, 0x19, 0xA5, 0xD5, 0x94, 0x46, 0xC0, 0x78, 0xF7, 0x7D, 0xD9, 0x9D, 0x0A, 0xCF, 0xEE, 0x0C, + 0x5C, 0x92, 0x85, 0x10, 0xF5, 0xEC, 0x2E, 0x48, 0xC1, 0x35, 0x86, 0x1E, 0x6A, 0xBE, 0xF0, 0x89, + 0x64, 0xF7, 0x4A, 0x71, 0xE7, 0x10, 0x6B, 0xEC, 0xC0, 0xC9, 0xB7, 0x94, 0x66, 0x27, 0x22, 0x2D, + 0xA2, 0x94, 0xAB, 0xBE, 0x36, 0xAC, 0x76, 0xB9, 0x2D, 0x8A, 0x04, 0xEF, 0x08, 0x3D, 0xA7, 0x9A, + 0xC7, 0x73, 0x78, 0xB2, 0xCD, 0x9E, 0x59, 0x90, 0x39, 0x1E, 0x54, 0x51, 0x18, 0x25, 0x22, 0x2A, + 0x38, 0x20, 0x73, 0xF1, 0x7F, 0x01, 0x07, 0x81, 0xA9, 0x3F, 0xE8, 0x90, 0x9C, 0xF6, 0x45, 0x14, + 0x8D, 0x82, 0xCB, 0xB0, 0x7D, 0x77, 0xA5, 0x97, 0x34, 0x81, 0x28, 0x6C, 0x1B, 0x0F, 0x60, 0x4B, + 0x35, 0xC5, 0x1C, 0xE4, 0xE2, 0x4C, 0x0A, 0xE1, 0xF9, 0xD0, 0xE8, 0xCC, 0x18, 0x25, 0xF6, 0xA0, + 0x41, 0xDF, 0x9B, 0x68, 0x75, 0x64, 0x0D, 0xE3, 0x1F, 0xA4, 0xA7, 0xFF, 0x02, 0xB5, 0x68, 0xA3, + 0x62, 0xAE, 0xD2, 0x1D, 0x36, 0x37, 0x18, 0x6C, 0xCE, 0x20, 0x25, 0xAF, 0xDD, 0x20, 0xB5, 0xF4, + 0xCF, 0x05, 0x3B, 0xF0, 0xD7, 0xB0, 0x43, 0xDB, 0xD7, 0xC7, 0x87, 0x1D, 0xD6, 0xD1, 0xD0, 0x33, + 0x20, 0x66, 0x10, 0x3C, 0x5E, 0x9D, 0xA8, 0x21, 0x48, 0x31, 0x65, 0x4C, 0xBD, 0xF5, 0x40, 0x97, + 0xC8, 0x0A, 0x87, 0x25, 0x0C, 0x54, 0x35, 0xCE, 0xEC, 0x76, 0xE8, 0xAD, 0x95, 0xCD, 0xC6, 0x7E, + 0xCD, 0x7C, 0xFD, 0x5F, 0x5B, 0xD6, 0x6B, 0xC6, 0xC4, 0x26, 0xA9, 0x16, 0xD7, 0xC8, 0xCE, 0x9E, + 0x3E, 0xB0, 0x81, 0xA1, 0x9A, 0xBE, 0x8A, 0xF9, 0x7D, 0xB0, 0x1B, 0x03, 0x9B, 0xBA, 0xF7, 0xF5, + 0x74, 0x13, 0x0F, 0x44, 0x51, 0x98, 0xAC, 0x56, 0x69, 0x24, 0xB1, 0xEA, 0xCD, 0x27, 0x25, 0xE5, + 0x58, 0x26, 0xCA, 0x44, 0xBA, 0x6D, 0xAA, 0x6E, 0x2F, 0xC8, 0x5E, 0x18, 0x6F, 0x08, 0xA0, 0xE8, + 0x57, 0xFB, 0x77, 0x99, 0x8A, 0xBD, 0x56, 0x1D, 0xD2, 0xD8, 0x63, 0x7A, 0xCE, 0xD3, 0xC9, 0xE2, + 0x99, 0xC2, 0x96, 0xB8, 0x8E, 0x88, 0x09, 0x80, 0xC6, 0x9A, 0xC3, 0xC5, 0xFB, 0xF5, 0x3C, 0x90, + 0x70, 0xAB, 0xF1, 0xA6, 0x80, 0x17, 0x2A, 0x25, 0xD3, 0xD2, 0x2B, 0xEE, 0xF5, 0xD2, 0x7F, 0xBD, + 0x2D, 0x83, 0xCC, 0x2A, 0x8C, 0xE2, 0xB4, 0xC4, 0xF4, 0x84, 0x34, 0x68, 0x04, 0xAD, 0x62, 0x27, + 0xE5, 0x19, 0x40, 0x17, 0xD7, 0x0A, 0xC4, 0x0A, 0x7E, 0x24, 0xBB, 0x38, 0xBC, 0xA3, 0x3B, 0x4A, + 0x58, 0x7C, 0x6B, 0xD2, 0x29, 0x46, 0xD6, 0xCF, 0x1C, 0x4B, 0xCC, 0x4E, 0x99, 0x28, 0xFC, 0x10, + 0xB1, 0x8B, 0x59, 0xF8, 0x2B, 0x6F, 0x43, 0x67, 0x01, 0x24, 0xFB, 0xCA, 0xB4, 0xBD, 0x35, 0x4B, + 0x7D, 0x50, 0xC0, 0x83, 0xD4, 0xB9, 0xC7, 0x37, 0x45, 0xB9, 0x24, 0xD7, 0x6D, 0x9D, 0xA6, 0x9C, + 0x7C, 0x1F, 0xE6, 0xB9, 0x97, 0x2C, 0x47, 0x5E, 0xCA, 0x30, 0xEB, 0xE5, 0xFD, 0x70, 0xD2, 0x37, + 0xE7, 0x6A, 0x3A, 0xEF, 0x00, 0xCF, 0x10, 0xF3, 0x3B, 0xA1, 0x62, 0xF0, 0x7D, 0xEA, 0x32, 0x50, + 0x87, 0x73, 0xAC, 0xB5, 0x61, 0x85, 0x6D, 0xDD, 0xD9, 0xD8, 0x84, 0xCD, 0x23, 0x3F, 0x11, 0x63, + 0xB1, 0xAB, 0xDF, 0x37, 0xAF, 0x84, 0x7C, 0x12, 0x77, 0x41, 0xFF, 0xF1, 0xF7, 0x5F, 0xF5, 0x40, + 0x23, 0xE1, 0x07, 0xC6, 0x89, 0x95, 0xF3, 0xA8, 0x5F, 0x1C, 0xE4, 0xE3, 0x86, 0x04, 0xD2, 0x17, + 0x52, 0xA3, 0x74, 0x51, 0x53, 0x6E, 0x44, 0x42, 0x92, 0x10, 0xBD, 0x7F, 0x5A, 0x13, 0x14, 0x85, + 0x59, 0x08, 0xF2, 0x87, 0x9A, 0x20, 0x98, 0xE8, 0x2E, 0xF1, 0x0F, 0x3D, 0x42, 0x79, 0x75, 0x88, + 0x45, 0x19, 0x8E, 0x6B, 0xF0, 0xCE, 0x22, 0x47, 0x30, 0x29, 0xC1, 0x94, 0xFE, 0x79, 0x4E, 0xDC, + 0xE3, 0x7F, 0x00, 0x4E, 0x67, 0x7D, 0xD7, 0x84, 0x2A, 0x01, 0x4E, 0x17, 0x07, 0x17, 0xD7, 0x1E, + 0x4D, 0xC5, 0x0B, 0x1C, 0x76, 0x8F, 0x02, 0x33, 0x26, 0xC6, 0x75, 0x35, 0xD2, 0x76, 0xAD, 0x8C, + 0xE9, 0x08, 0x9E, 0xCD, 0x07, 0x72, 0x3A, 0x61, 0x29, 0x2C, 0x99, 0xB9, 0x72, 0x6F, 0xF7, 0x69, + 0xAF, 0xEA, 0x3E, 0x56, 0xBE, 0xD8, 0x3A, 0xD7, 0xFC, 0x86, 0xE7, 0xB8, 0x45, 0x37, 0xF7, 0xE0, + 0x47, 0xD4, 0x0B, 0x36, 0xD4, 0xF1, 0x4B, 0x28, 0x2B, 0xE5, 0x1E, 0xB1, 0x06, 0x5B, 0x39, 0x59, + 0x34, 0x3D, 0x05, 0x23, 0x49, 0x8D, 0x9D, 0xC9, 0xEA, 0xC3, 0x42, 0x00, 0x65, 0x75, 0x09, 0xEC, + 0x30, 0xB6, 0xDB, 0xFB, 0x93, 0xFA, 0x93, 0x6D, 0x8D, 0xBE, 0xF5, 0x8D, 0x1E, 0x22, 0xB3, 0xAB, + 0x90, 0xB1, 0xA4, 0xE8, 0xCD, 0xB0, 0xBB, 0x2A, 0xF7, 0x39, 0xF2, 0x9C, 0x73, 0x18, 0xCF, 0xD4, + 0x14, 0xB5, 0xDD, 0x1A, 0x65, 0x6B, 0x47, 0x11, 0x16, 0xAD, 0xB4, 0xFC, 0xA3, 0x31, 0x56, 0xBD, + 0xBD, 0xB2, 0xC4, 0xCC, 0x39, 0xDA, 0x60, 0x86, 0x4E, 0x7F, 0x37, 0x99, 0xCF, 0x88, 0x47, 0x2A, + 0x1D, 0x09, 0xDA, 0xE1, 0x07, 0xF0, 0x1B, 0x97, 0x9E, 0x13, 0x43, 0x9E, 0x99, 0xA9, 0x2B, 0x1C, + 0x2D, 0xDB, 0xED, 0x0C, 0x58, 0xD2, 0xBE, 0x25, 0x25, 0x44, 0x62, 0x37, 0x7A, 0x50, 0x9A, 0x68, + 0x3E, 0x9A, 0xE5, 0xE2, 0xCA, 0x3F, 0xFF, 0x01, 0xF8, 0x17, 0xF4, 0xA8, 0xFF, 0x8E, 0x99, 0xDB, + 0x6E, 0x13, 0xD7, 0x7F, 0x1F, 0xDE, 0xDE, 0x2F, 0x9F, 0x37, 0x60, 0x41, 0xF0, 0xA0, 0xB7, 0x4F, + 0x80, 0x7D, 0xBA, 0xF9, 0xF1, 0xA6, 0x2C, 0x03, 0xD7, 0x3F, 0x3C, 0xC6, 0x45, 0x7C, 0xFF, 0x40, + 0x7C, 0x6D, 0x73, 0x6D, 0x42, 0x8F, 0x87, 0xDA, 0x66, 0xB3, 0xDF, 0x20, 0x17, 0x27, 0x86, 0x28, + 0xD6, 0x7F, 0x90, 0x0D, 0xFC, 0x62, 0x87, 0x59, 0x6B, 0x15, 0xB3, 0xBD, 0xF5, 0x15, 0x5F, 0x12, + 0x21, 0xE3, 0x50, 0x6A, 0xEA, 0x83, 0x9A, 0x1B, 0xC9, 0x29, 0x44, 0x32, 0xD7, 0x72, 0x68, 0x1B, + 0xA6, 0x1B, 0xDD, 0x65, 0xDB, 0x0A, 0xF7, 0xEE, 0xF1, 0xF2, 0xA6, 0x68, 0x6D, 0xEB, 0xB9, 0xF2, + 0x5A, 0xF9, 0xEE, 0xA3, 0xD0, 0xAE, 0xE2, 0x18, 0x29, 0xFF, 0xFD, 0x9B, 0x94, 0x6C, 0x03, 0xFC, + 0x3C, 0xF2, 0xEB, 0x3D, 0x50, 0x16, 0xA5, 0xB6, 0x64, 0x25, 0xFC, 0x3F, 0x79, 0xC0, 0x7F, 0x22, + 0x0C, 0x06, 0xFB, 0xAA, 0xAC, 0x2D, 0xC1, 0x1F, 0x24, 0x3F, 0x72, 0x87, 0xBE, 0xE5, 0xFD, 0x25, + 0x70, 0x65, 0x31, 0xA1, 0xD8, 0x63, 0xD3, 0xB6, 0x67, 0x99, 0xAF, 0xC4, 0x78, 0x44, 0xC7, 0x60, + 0x95, 0x9B, 0x2F, 0x3C, 0x0A, 0x44, 0xEB, 0x80, 0x34, 0x50, 0xE9, 0x01, 0x37, 0xF8, 0x55, 0x4D, + 0xE1, 0x73, 0x24, 0xC5, 0xF2, 0x9D, 0xCD, 0x70, 0x1A, 0x77, 0x57, 0x19, 0xF6, 0xA8, 0xEC, 0x69, + 0x25, 0xEF, 0xE4, 0xE2, 0x8C, 0x9A, 0x51, 0x90, 0x95, 0x21, 0xC5, 0xC1, 0x0C, 0xAD, 0x33, 0xF7, + 0x0E, 0xC5, 0xC4, 0xFF, 0x3D, 0xA9, 0xEA, 0x36, 0xCF, 0x15, 0x57, 0xB8, 0x37, 0xB7, 0x9A, 0x92, + 0x59, 0xDF, 0x91, 0x5C, 0x07, 0x78, 0xAD, 0xE6, 0xE0, 0x71, 0xD7, 0x17, 0x65, 0x8A, 0x62, 0x52, + 0x30, 0x95, 0xA1, 0xC5, 0x2F, 0xC7, 0x6D, 0x94, 0xDA, 0xA8, 0xFE, 0xF8, 0x28, 0x99, 0xC9, 0x9D, + 0x28, 0xFB, 0x6D, 0x22, 0xD0, 0x44, 0xAE, 0x02, 0x89, 0xEA, 0x93, 0xC6, 0x11, 0xC9, 0x19, 0x35, + 0x82, 0x7A, 0x76, 0x87, 0x9A, 0x5D, 0x39, 0x9E, 0x5A, 0x6B, 0x53, 0x45, 0x2F, 0x10, 0x6E, 0x86, + 0x95, 0xB5, 0x8F, 0x87, 0xB6, 0x37, 0x58, 0x48, 0x16, 0x01, 0x4D, 0xE1, 0xD1, 0x13, 0x21, 0xC3, + 0xAA, 0x8F, 0xDE, 0xE1, 0xFF, 0x5F, 0xEA, 0xBC, 0xBC, 0xDF, 0xF2, 0xB9, 0x0D, 0x96, 0x53, 0xF0, + 0x08, 0xB9, 0x01, 0x9E, 0x70, 0x87, 0xF3, 0x89, 0xFA, 0x1A, 0xB0, 0x06, 0xF3, 0xEC, 0x13, 0xC5, + 0x8D, 0x21, 0xF5, 0x2B, 0x47, 0x35, 0x48, 0x01, 0x34, 0xA2, 0x8D, 0x55, 0x24, 0x37, 0xFC, 0x5A, + 0x43, 0x0D, 0x0B, 0x3E, 0x0A, 0x95, 0x5B, 0xEF, 0x9F, 0x38, 0x41, 0x25, 0x52, 0xE3, 0x1C, 0xBF, + 0x7D, 0x3B, 0x1C, 0x32, 0x83, 0xBF, 0xBF, 0x69, 0xD2, 0xB5, 0x73, 0xD4, 0x5F, 0x4F, 0x0E, 0xBA, + 0xFF, 0x6C, 0xB6, 0xB4, 0xBB, 0x62, 0xD7, 0xEB, 0x5C, 0xC8, 0x44, 0x50, 0x38, 0xAD, 0x4F, 0xA0, + 0xB2, 0x90, 0x0F, 0x58, 0x2E, 0x93, 0x0F, 0xE8, 0xEB, 0x2F, 0x65, 0x76, 0x56, 0xD9, 0xDD, 0x79, + 0x75, 0xE1, 0xAD, 0x4A, 0x1A, 0x24, 0x5F, 0xE0, 0x82, 0x62, 0xF9, 0x96, 0x90, 0xD6, 0x4F, 0xFC, + 0xF6, 0x9E, 0xAE, 0x1C, 0xDA, 0x4D, 0x3B, 0xC4, 0x44, 0x4B, 0xAC, 0x69, 0xD7, 0x0E, 0x89, 0xAD, + 0xED, 0xF8, 0x6A, 0x8C, 0x4B, 0xAE, 0xC4, 0xEA, 0x02, 0x78, 0x0B, 0x41, 0xF6, 0x98, 0xE9, 0x1E, + 0xE2, 0x17, 0x0A, 0x0A, 0xA3, 0x1E, 0xE3, 0xF4, 0xEE, 0x7E, 0x3C, 0x81, 0x52, 0xCB, 0x2E, 0xF2, + 0x75, 0x0F, 0xD9, 0xD3, 0x58, 0xE0, 0xFF, 0x14, 0xA1, 0x4F, 0x7F, 0x19, 0xCA, 0xD1, 0xDA, 0x32, + 0x1F, 0xCD, 0x74, 0x41, 0x22, 0x8A, 0xBF, 0x96, 0x04, 0x35, 0xB7, 0x44, 0x86, 0x39, 0x59, 0xC6, + 0x96, 0x17, 0x99, 0x72, 0x72, 0xA1, 0x4E, 0x33, 0x65, 0x02, 0x1C, 0xA7, 0x1D, 0x6C, 0x24, 0xE1, + 0x85, 0x6A, 0x1E, 0x02, 0x88, 0xCE, 0x0E, 0x6D, 0x5F, 0x6B, 0x38, 0xD5, 0xA0, 0x5F, 0x15, 0x3C, + 0x4B, 0xBD, 0xD3, 0x6E, 0x0A, 0x70, 0x10, 0x3F, 0x6A, 0xB5, 0xAB, 0x72, 0x7D, 0x78, 0x42, 0x79, + 0x23, 0x16, 0x49, 0x4F, 0x97, 0x15, 0xF3, 0xA7, 0x6E, 0x73, 0x41, 0xB2, 0x78, 0x21, 0x3F, 0x32, + 0x17, 0x7F, 0x97, 0xBB, 0xA8, 0xDE, 0x17, 0xD6, 0xFB, 0x32, 0x95, 0x3D, 0x93, 0x07, 0x9D, 0xD2, + 0x5E, 0x99, 0xCD, 0x7C, 0x3E, 0x92, 0x1B, 0xCE, 0xA8, 0xA9, 0xAC, 0xF5, 0xFA, 0xAB, 0x23, 0xCB, + 0xA1, 0xD6, 0xF9, 0x09, 0x30, 0x5E, 0x7E, 0xF5, 0x24, 0x80, 0x5B, 0x5C, 0x5B, 0x3E, 0x76, 0xA6, + 0xE5, 0x21, 0x7E, 0xB3, 0x40, 0x5F, 0x75, 0xE7, 0x1D, 0x93, 0x41, 0x90, 0xF6, 0xAB, 0x98, 0x72, + 0x56, 0x8C, 0xFF, 0x06, 0xC5, 0x2C, 0xE0, 0xAE, 0xE6, 0xD0, 0x38, 0xC9, 0x3D, 0x88, 0x35, 0xF5, + 0x31, 0x36, 0x95, 0x49, 0x9C, 0x0C, 0x3F, 0x8D, 0xBC, 0xAA, 0xEC, 0x1B, 0x94, 0xCB, 0x77, 0x35, + 0xE8, 0xD8, 0xBF, 0x03, 0x81, 0xB2, 0x84, 0x06, 0x7C, 0x98, 0x58, 0x7D, 0x49, 0x7C, 0x87, 0xDF, + 0x69, 0xCB, 0xC7, 0xA4, 0x02, 0x68, 0xFD, 0x5F, 0x2C, 0x0B, 0xEB, 0xA5, 0x3A, 0xF3, 0x8F, 0x9A, + 0xA6, 0xA0, 0x10, 0x22, 0x05, 0x88, 0xFD, 0x85, 0x52, 0x14, 0x8F, 0x94, 0x2F, 0xA6, 0x1F, 0xE5, + 0x90, 0xE8, 0xFF, 0xEB, 0x1B, 0xD1, 0x76, 0x9B, 0xA2, 0x69, 0x83, 0x3F, 0x38, 0xC0, 0x58, 0x62, + 0xDA, 0x85, 0x7C, 0x59, 0xD1, 0xFD, 0x70, 0xCC, 0x16, 0xE8, 0xE5, 0x57, 0xBB, 0x2D, 0xE8, 0x99, + 0x5D, 0xC0, 0x9C, 0x07, 0x21, 0x56, 0x14, 0xEE, 0xA5, 0x28, 0x6B, 0x4E, 0x1A, 0x1E, 0x41, 0xBB, + 0x60, 0x63, 0x53, 0x5D, 0xAA, 0xB3, 0x9A, 0x7A, 0xB2, 0xAD, 0x6E, 0x2A, 0x2A, 0x6A, 0x00, 0xF7, + 0xEA, 0x92, 0xB8, 0x12, 0x73, 0x5D, 0xA7, 0x58, 0xA3, 0xE1, 0xB3, 0xB2, 0x6B, 0x79, 0x1E, 0xCD, + 0xD1, 0x1C, 0xFB, 0x89, 0xF9, 0xE5, 0xD8, 0xF9, 0x7C, 0xEA, 0xEF, 0x1D, 0x13, 0x86, 0x2E, 0xDD, + 0xFE, 0x52, 0x81, 0xC8, 0xF9, 0xE9, 0x42, 0x44, 0x36, 0x0B, 0x3C, 0xD9, 0x14, 0x09, 0x73, 0xCD, + 0x78, 0x19, 0xEF, 0x9D, 0xC5, 0x90, 0xB6, 0xE7, 0x45, 0x47, 0xEE, 0x0E, 0x7C, 0x0F, 0x5D, 0x4B, + 0xCC, 0x1D, 0x66, 0xC5, 0xC4, 0x4D, 0xAB, 0x55, 0xF0, 0x83, 0x68, 0xFE, 0x5C, 0xAB, 0x11, 0x71, + 0xB7, 0x45, 0xB4, 0x55, 0x1B, 0xDA, 0x77, 0x44, 0x07, 0x6A, 0x13, 0x99, 0xF4, 0x9D, 0x2B, 0xF8, + 0x78, 0x6B, 0x2E, 0x4C, 0x6B, 0xC5, 0x18, 0x9B, 0x7D, 0x26, 0xF8, 0x78, 0x53, 0x27, 0x14, 0x83, + 0x94, 0xA3, 0x9F, 0x5C, 0xAF, 0x84, 0x9B, 0x76, 0x9F, 0x77, 0xC8, 0x18, 0xA6, 0x00, 0x38, 0x67, + 0x6A, 0x08, 0xEE, 0xE3, 0x43, 0x3D, 0x09, 0xD9, 0xDD, 0xC9, 0x29, 0x33, 0x80, 0x56, 0x70, 0xD6, + 0x98, 0x50, 0x0C, 0x12, 0xC7, 0xF8, 0x3C, 0xC4, 0xFB, 0x9F, 0xFE, 0xFD, 0x5D, 0xAE, 0x9E, 0x1B, + 0x1E, 0x09, 0x99, 0xBC, 0xA5, 0x2A, 0x1A, 0xD0, 0x03, 0x41, 0x2D, 0xCC, 0xEB, 0x28, 0x6A, 0xCC, + 0xEE, 0x1F, 0x3F, 0x97, 0xDA, 0x97, 0xD5, 0x1A, 0xFF, 0x9B, 0xFD, 0xAC, 0x5A, 0x3F, 0xAB, 0x6F, + 0x73, 0x76, 0x5C, 0x28, 0xBE, 0x3D, 0x41, 0x01, 0x25, 0xFD, 0x3A, 0x72, 0x41, 0xA5, 0x8F, 0x99, + 0x03, 0x77, 0x11, 0x81, 0xEB, 0x35, 0x3D, 0x46, 0xA7, 0xA0, 0x1C, 0xDE, 0x9C, 0xD7, 0x8B, 0xD7, + 0x0A, 0x3C, 0x5D, 0x25, 0xEC, 0xF3, 0x3D, 0x54, 0xEF, 0x6A, 0x15, 0x59, 0x9B, 0xD5, 0x6F, 0xC5, + 0x1E, 0x7F, 0x55, 0x28, 0x50, 0x6F, 0xFA, 0xE8, 0x05, 0x59, 0x50, 0xD6, 0x80, 0x8C, 0xFD, 0x42, + 0x15, 0xEB, 0xC6, 0x0D, 0x62, 0xE2, 0xF3, 0x52, 0x76, 0xF7, 0x1A, 0xA0, 0x25, 0x34, 0x5F, 0x66, + 0xEA, 0xE7, 0xD9, 0x3A, 0x9C, 0x6C, 0x56, 0x7E, 0x13, 0x8F, 0xC7, 0xD1, 0xC1, 0x93, 0x69, 0x19, + 0x7C, 0xBE, 0xCE, 0x16, 0x6F, 0x4D, 0xDB, 0xC6, 0x80, 0x09, 0xCC, 0xB9, 0x72, 0xBA, 0x5B, 0xF3, + 0x49, 0xB1, 0x86, 0xBB, 0x49, 0xA0, 0x2C, 0xF1, 0x82, 0x88, 0x9F, 0xF7, 0x99, 0xB9, 0x2A, 0x94, + 0xE5, 0xA7, 0xB7, 0xDB, 0x7B, 0x7B, 0xBF, 0x6A, 0xDA, 0x69, 0xB5, 0x6B, 0xB9, 0x8A, 0x07, 0xF3, + 0xF8, 0x89, 0x1B, 0x9D, 0xA7, 0x46, 0x3A, 0x13, 0x04, 0xFD, 0x3A, 0x2D, 0x76, 0xCA, 0xD6, 0x00, + 0xF3, 0xED, 0x42, 0x1C, 0x98, 0x46, 0x1E, 0x50, 0xE0, 0x59, 0xE2, 0x67, 0x03, 0x7E, 0xAF, 0xEB, + 0xD3, 0x76, 0x7E, 0x01, 0xF8, 0x85, 0x33, 0x0F, 0x07, 0x99, 0x87, 0x6A, 0x37, 0xE9, 0x29, 0x30, + 0xA4, 0xE6, 0x04, 0xF0, 0x1E, 0x25, 0xE5, 0x88, 0x37, 0xF1, 0x18, 0x85, 0xE6, 0xD0, 0x53, 0x52, + 0x47, 0x45, 0xE0, 0x07, 0x0F, 0x27, 0xE1, 0x8D, 0xBB, 0x21, 0xBD, 0xA8, 0xC8, 0x93, 0xBD, 0xD3, + 0x66, 0x7C, 0xED, 0x24, 0x33, 0xE1, 0xC5, 0x5D, 0x7E, 0xE2, 0xDA, 0x71, 0x21, 0xD0, 0x3A, 0x70, + 0xB0, 0xB3, 0x70, 0x33, 0x64, 0x7B, 0x8D, 0x4E, 0x0F, 0xAA, 0x2B, 0x25, 0xBF, 0x54, 0x5C, 0x08, + 0xFD, 0x3B, 0x0A, 0xE0, 0x70, 0x2E, 0xFF, 0x4B, 0x1B, 0xA5, 0x6D, 0x19, 0x46, 0x1E, 0x84, 0xAF, + 0x32, 0x42, 0x55, 0xC9, 0xDB, 0x32, 0xC6, 0xCD, 0x06, 0x33, 0x53, 0xE5, 0x95, 0x71, 0x4E, 0xDE, + 0xE5, 0x83, 0xD2, 0x48, 0xCB, 0x32, 0x69, 0xA6, 0xFA, 0xA2, 0x8F, 0xC5, 0x45, 0x3A, 0x04, 0xEB, + 0x5B, 0xAB, 0x1B, 0x9F, 0xFF, 0xB7, 0x80, 0x50, 0x34, 0xB3, 0x17, 0xBC, 0xD3, 0x29, 0x5E, 0x53, + 0x0E, 0x98, 0xA7, 0x2D, 0x8D, 0xE0, 0xB5, 0x45, 0xEB, 0x24, 0x3D, 0xB6, 0x4E, 0xFF, 0x95, 0x6E, + 0x17, 0xAC, 0xA6, 0x8A, 0x1D, 0x6F, 0x7F, 0xDB, 0x74, 0x13, 0x81, 0x51, 0x40, 0x82, 0x8B, 0xAB, + 0x70, 0x71, 0x7F, 0x19, 0x63, 0x41, 0x1A, 0x12, 0x80, 0x97, 0x3E, 0x58, 0xFE, 0xE7, 0x9C, 0xA9, + 0x08, 0xB1, 0x41, 0x30, 0x69, 0xBA, 0xC0, 0x81, 0xE1, 0x0B, 0x87, 0x14, 0xBB, 0xD8, 0x9E, 0x4A, + 0x33, 0x92, 0x3B, 0xBD, 0x7F, 0xD4, 0x95, 0x3C, 0x2D, 0x45, 0xB1, 0x2A, 0x9B, 0x9B, 0xC2, 0x86, + 0xA0, 0x25, 0x7C, 0x94, 0x55, 0x05, 0xE5, 0x2D, 0xCB, 0xA4, 0x0B, 0x0B, 0x25, 0xBF, 0x8B, 0xFE, + 0xA0, 0xF2, 0x65, 0xA0, 0x9C, 0x90, 0x4F, 0xE1, 0xE9, 0x2B, 0x40, 0x60, 0x7F, 0x23, 0x82, 0x8A, + 0x89, 0x50, 0x72, 0x9C, 0x07, 0xBD, 0xD0, 0x84, 0x88, 0xA6, 0xB6, 0x3A, 0x43, 0x87, 0xBB, 0xDB, + 0x3E, 0x35, 0x6C, 0xBA, 0x51, 0x2E, 0xB4, 0xE7, 0xF6, 0xC4, 0x05, 0xE0, 0x95, 0x42, 0x96, 0x3E, + 0xE2, 0x39, 0xE9, 0x18, 0x8F, 0xD4, 0x9B, 0xEC, 0x18, 0x95, 0x8F, 0x79, 0xB8, 0xE3, 0xF4, 0x0D, + 0xD1, 0x15, 0x52, 0x26, 0xDA, 0x04, 0x9C, 0xA2, 0x08, 0xE4, 0x00, 0xB1, 0xD1, 0x38, 0x5C, 0x54, + 0x1E, 0xFB, 0x00, 0xFE, 0x22, 0xF8, 0x1D, 0xC6, 0x94, 0x8E, 0xA6, 0xEE, 0x6D, 0x07, 0x1F, 0x2B, + 0x06, 0x2C, 0x92, 0x6D, 0xEF, 0x86, 0x2F, 0x03, 0x7A, 0xBF, 0x05, 0x63, 0x2F, 0x43, 0x3E, 0xA7, + 0xF0, 0x5D, 0xD3, 0x82, 0xBF, 0x0B, 0xE6, 0x76, 0xEC, 0x8E, 0x5E, 0x6F, 0xD4, 0x88, 0xEF, 0xBB, + 0xED, 0xAF, 0x14, 0xC0, 0xA6, 0x51, 0x04, 0x7B, 0x60, 0x98, 0xB8, 0x7A, 0xF9, 0x1A, 0x5A, 0x28, + 0xC4, 0x40, 0x10, 0xBA, 0x4A, 0x8D, 0x0D, 0x30, 0xF9, 0x09, 0xDA, 0x6E, 0x1C, 0x78, 0xF7, 0x6A, + 0xAC, 0x2F, 0x49, 0xC6, 0x31, 0x56, 0x9D, 0x58, 0x63, 0x74, 0x6E, 0xAB, 0xA9, 0xD4, 0xF4, 0xC9, + 0x84, 0xA3, 0x9B, 0x97, 0x7A, 0x0E, 0x9E, 0xED, 0x7A, 0xC4, 0x01, 0xFB, 0xC3, 0xD6, 0x4F, 0x97, + 0x38, 0x84, 0x2F, 0x97, 0xF0, 0x33, 0x9B, 0x8A, 0x9C, 0x40, 0x23, 0x11, 0xDA, 0xC2, 0x5E, 0x28, + 0x5A, 0x78, 0x95, 0xF1, 0xB9, 0x41, 0x12, 0x4A, 0x77, 0x90, 0x86, 0xEC, 0xB3, 0xCC, 0x6D, 0x4C, + 0x40, 0x68, 0xAE, 0x40, 0x2F, 0x96, 0x9A, 0x1B, 0xA1, 0x46, 0x67, 0x1C, 0xE3, 0x54, 0xB7, 0x8A, + 0xF1, 0xAC, 0x38, 0x92, 0x1E, 0xBA, 0xD4, 0xD2, 0xCE, 0x46, 0x11, 0xA7, 0xCC, 0x73, 0xE3, 0x49, + 0x00, 0x9B, 0x93, 0xDE, 0xA6, 0x81, 0x3E, 0x85, 0x51, 0xB7, 0x43, 0x41, 0x64, 0xAC, 0x5B, 0x15, + 0xB7, 0xBC, 0x61, 0xF5, 0x87, 0xC4, 0x3D, 0xD1, 0x92, 0x57, 0x05, 0x27, 0x3E, 0x82, 0x5A, 0xCE, + 0xED, 0x5A, 0x59, 0x3B, 0x21, 0x01, 0x13, 0xB2, 0x67, 0x0F, 0x4D, 0xC4, 0x01, 0x9D, 0x19, 0x15, + 0x67, 0x02, 0xFF, 0xF7, 0xB7, 0xDD, 0xCB, 0xDB, 0x81, 0x13, 0xBA, 0x0C, 0x69, 0x32, 0x43, 0xBD, + 0x1A, 0x4F, 0xC8, 0x57, 0xD5, 0x3F, 0xE9, 0xBB, 0xC0, 0x0F, 0x98, 0xB5, 0x35, 0x65, 0x44, 0x7C, + 0x49, 0x05, 0x0B, 0x49, 0xE1, 0x6D, 0x34, 0x28, 0x2A, 0x77, 0xFE, 0x86, 0xC2, 0x87, 0x37, 0x2F, + 0x02, 0x53, 0x68, 0xC7, 0xDA, 0xF8, 0xAE, 0xA6, 0xE1, 0x47, 0xFA, 0xB8, 0xEE, 0x2D, 0x7E, 0xF0, + 0xB1, 0xE5, 0x64, 0xB6, 0x30, 0xC8, 0x0A, 0x5F, 0xB1, 0x6B, 0x11, 0xB2, 0x86, 0xD7, 0x4B, 0x0F, + 0x34, 0x4D, 0xEC, 0x5C, 0x72, 0x70, 0x05, 0xE8, 0xB4, 0x26, 0x76, 0x0F, 0x6E, 0x2D, 0x5E, 0x1E, + 0x80, 0x02, 0x6D, 0x4C, 0xCF, 0x92, 0x55, 0x5D, 0x2A, 0x2D, 0xDC, 0xBB, 0x01, 0xCD, 0x53, 0x06, + 0x02, 0xE7, 0x29, 0x1C, 0x34, 0x40, 0x88, 0x39, 0x8E, 0xD3, 0x58, 0x9A, 0x80, 0x18, 0xA1, 0xDD, + 0xC9, 0xB1, 0x59, 0x6B, 0x1D, 0xA2, 0xAE, 0xE6, 0x39, 0x1E, 0x37, 0x99, 0xFA, 0x1A, 0x88, 0x0F, + 0x26, 0x6A, 0x0D, 0xEF, 0x16, 0xE1, 0x2A, 0xEB, 0x22, 0x5D, 0x7B, 0xD3, 0x25, 0x93, 0x2C, 0x84, + 0xE5, 0x8D, 0xFA, 0xD6, 0x67, 0xE4, 0x36, 0x68, 0x80, 0x72, 0x78, 0xD3, 0x3B, 0xD1, 0xEF, 0xC0, + 0xA8, 0x1E, 0x32, 0x13, 0x2E, 0x02, 0xB1, 0xDF, 0x05, 0xA7, 0x3F, 0x7C, 0xAC, 0x5E, 0xC2, 0x15, + 0x4B, 0xD0, 0x94, 0xA1, 0x3C, 0x6C, 0x65, 0xDF, 0x6B, 0x05, 0x1F, 0x09, 0x09, 0x7D, 0xEA, 0x11, + 0x38, 0x85, 0x12, 0x7F, 0xE2, 0x0C, 0x8E, 0xF5, 0xED, 0xF8, 0x24, 0x6F, 0xCA, 0xDB, 0xDA, 0x65, + 0x08, 0xCA, 0x1F, 0x17, 0x3E, 0xFF, 0x68, 0x7B, 0xAA, 0x12, 0xDD, 0x98, 0x65, 0x94, 0x14, 0x63, + 0x8A, 0xC7, 0x56, 0xE2, 0x07, 0x2A, 0x53, 0xAB, 0xA9, 0x42, 0xB9, 0xF9, 0xBE, 0x38, 0x06, 0xB7, + 0xD1, 0xE6, 0xDF, 0x5A, 0xE3, 0x83, 0xFF, 0xE1, 0xAF, 0xE1, 0xF7, 0x89, 0xE9, 0x3B, 0xDC, 0x9A, + 0x23, 0x3B, 0x4C, 0xD1, 0xC6, 0xA0, 0xD5, 0x40, 0x01, 0x20, 0x7D, 0x2B, 0xEB, 0x60, 0x8E, 0x40, + 0x62, 0xC9, 0x26, 0xD7, 0x1C, 0xE6, 0x6D, 0xB6, 0x87, 0xC4, 0xCE, 0x19, 0xFC, 0xBB, 0x59, 0x3A, + 0x66, 0x21, 0x22, 0x91, 0x0C, 0x59, 0x66, 0x54, 0x4D, 0x86, 0xCA, 0xA2, 0x11, 0x72, 0xB6, 0xE6, + 0x04, 0x50, 0x25, 0x38, 0x9F, 0x87, 0x40, 0x9C, 0x5C, 0xB4, 0xFC, 0xD1, 0x04, 0xC0, 0xE1, 0xE2, + 0xC9, 0xFB, 0xD2, 0xBC, 0xE7, 0xB2, 0x38, 0x6B, 0x98, 0xAB, 0x90, 0x24, 0xBB, 0xB0, 0x45, 0xBA, + 0xEB, 0x29, 0xBD, 0xA6, 0xCD, 0xCC, 0x91, 0x7A, 0xEA, 0x2E, 0x84, 0x78, 0x6E, 0x07, 0x78, 0x1D, + 0x73, 0x14, 0xC4, 0x1F, 0x3D, 0x75, 0x72, 0x8E, 0xA0, 0x70, 0xE9, 0x93, 0xC2, 0x2C, 0x2F, 0x98, + 0x46, 0x07, 0x07, 0x12, 0x32, 0xFE, 0xDE, 0x2E, 0x24, 0xD5, 0xD0, 0xA3, 0x5A, 0x0C, 0xB4, 0x1D, + 0xD7, 0x57, 0xAB, 0x51, 0xAE, 0x0A, 0x19, 0xBD, 0x0D, 0x0B, 0xCA, 0x8A, 0x3B, 0x64, 0xFB, 0xF5, + 0x43, 0xC5, 0x04, 0xB1, 0x16, 0xC5, 0x34, 0xF7, 0x63, 0xEF, 0xC9, 0xBA, 0x94, 0x6A, 0xA4, 0x04, + 0x49, 0xB8, 0xF4, 0xF5, 0x3C, 0x0D, 0x84, 0xC3, 0x4B, 0xDE, 0xF1, 0xD5, 0x62, 0x15, 0x76, 0x84, + 0xED, 0xA4, 0x8A, 0x25, 0x3D, 0x87, 0xB7, 0xEA, 0x26, 0xDA, 0xCE, 0xB8, 0x7E, 0x8A, 0xDB, 0xAB, + 0x70, 0xB1, 0x18, 0x53, 0xEA, 0xF4, 0x74, 0xCB, 0x9A, 0x2B, 0x10, 0x5A, 0x4F, 0x06, 0x2B, 0x6B, + 0x4A, 0xF0, 0xF3, 0xB2, 0x10, 0x14, 0x9D, 0xBD, 0x18, 0x46, 0x3E, 0x7F, 0xAD, 0xB3, 0x03, 0xDD, + 0x80, 0xE2, 0xA5, 0x5D, 0x87, 0xAD, 0x67, 0x1C, 0x20, 0x06, 0xFD, 0x62, 0x65, 0x5D, 0x12, 0xC5, + 0x0A, 0x8C, 0x99, 0x8B, 0x97, 0xA1, 0x1F, 0x06, 0x8A, 0x78, 0x7A, 0xA5, 0x46, 0x65, 0xA8, 0xFA, + 0xC4, 0x81, 0x99, 0x02, 0x16, 0x7C, 0xB4, 0x09, 0xAD, 0xE8, 0x35, 0x2E, 0x6B, 0x4F, 0x55, 0xAC, + 0x23, 0x41, 0xA8, 0x5A, 0x0C, 0x71, 0x7E, 0x08, 0x3E, 0x6D, 0x5B, 0x46, 0x92, 0x3B, 0x8B, 0x8C, + 0xBE, 0x09, 0x52, 0xEA, 0xC5, 0xAE, 0x1B, 0x2A, 0xC8, 0x2D, 0x36, 0xE7, 0x2E, 0xCF, 0xA6, 0x30, + 0x9F, 0x14, 0xB2, 0xFA, 0xA2, 0xA3, 0xFF, 0xC7, 0x0B, 0xA6, 0xC8, 0x8C, 0xCD, 0xB3, 0x0B, 0xFC, + 0x76, 0x9F, 0xA1, 0xB9, 0x34, 0x86, 0xB5, 0x5B, 0x4C, 0x3D, 0x87, 0xA0, 0x5D, 0xE2, 0x95, 0x65, + 0xCF, 0xCD, 0x16, 0x40, 0x7D, 0x1B, 0xB1, 0xB8, 0x83, 0x37, 0x14, 0x6E, 0x02, 0xB2, 0x8E, 0x17, + 0x9E, 0x10, 0x87, 0x83, 0x62, 0x57, 0x60, 0x98, 0xA7, 0xE5, 0xCB, 0x82, 0x6E, 0xCC, 0xC7, 0x63, + 0x99, 0xB8, 0x1D, 0xA9, 0xED, 0x5B, 0xE9, 0x0E, 0xC8, 0x7D, 0xCE, 0x48, 0xE4, 0xE4, 0x3F, 0x1C, + 0x77, 0xBF, 0xEF, 0x3A, 0x63, 0x25, 0xAA, 0xDE, 0x2D, 0xC2, 0x42, 0x22, 0xEC, 0x99, 0xB6, 0xBF, + 0x65, 0xA0, 0x2A, 0x5C, 0x51, 0x63, 0x9D, 0xFB, 0x3F, 0xA0, 0x7E, 0x2B, 0xCC, 0x04, 0xE1, 0x74, + 0x13, 0x61, 0x80, 0x15, 0x3C, 0x2F, 0x9E, 0x3E, 0x63, 0x24, 0xA2, 0x13, 0xF9, 0xCD, 0xF6, 0xA9, + 0x88, 0x3A, 0xC9, 0x1F, 0xE9, 0xF2, 0x5F, 0x04, 0xD3, 0xE7, 0x00, 0x4B, 0xCD, 0xA5, 0x60, 0xBE, + 0x49, 0x89, 0xCC, 0x68, 0x48, 0x51, 0xEC, 0x7D, 0x8B, 0xDD, 0x23, 0xF0, 0x5D, 0xDC, 0x46, 0xA7, + 0x35, 0x77, 0xBF, 0x2D, 0x5C, 0xDB, 0x8B, 0x11, 0xE9, 0x15, 0xE6, 0xC7, 0x50, 0xEF, 0x01, 0x5A, + 0x4D, 0x04, 0x5D, 0xBF, 0xF9, 0x52, 0x36, 0xDE, 0x74, 0xE5, 0xF6, 0xF3, 0x37, 0x45, 0x28, 0x85, + 0x86, 0x9E, 0x1E, 0xFA, 0xF9, 0xB9, 0x1A, 0x04, 0xD7, 0xE7, 0xCB, 0xDC, 0x47, 0xFB, 0x49, 0x34, + 0x3A, 0x63, 0x26, 0x2D, 0x73, 0x6F, 0xC6, 0x28, 0xEE, 0x83, 0xBD, 0x8F, 0x2D, 0xF2, 0x1A, 0x19, + 0x75, 0x1B, 0xB6, 0x60, 0x4C, 0x38, 0x3D, 0xD7, 0x4D, 0x66, 0x7F, 0x01, 0xCF, 0x20, 0x1D, 0x45, + 0xD5, 0x32, 0x24, 0x96, 0x15, 0x0E, 0x5C, 0x6A, 0xD3, 0xE9, 0xC5, 0xD1, 0xF9, 0x11, 0x94, 0x41, + 0xD0, 0xC8, 0xBD, 0xBD, 0x17, 0xFB, 0x0A, 0x20, 0x89, 0x05, 0xBA, 0xCB, 0xF6, 0xBF, 0x9E, 0x83, + 0x44, 0x04, 0x54, 0x54, 0xA3, 0xDC, 0x1D, 0xEF, 0x3C, 0x01, 0x07, 0x80, 0x8A, 0x4F, 0x15, 0x3E, + 0x2D, 0xFE, 0xAF, 0xEB, 0x71, 0xA3, 0xE7, 0x20, 0x56, 0x2A, 0x19, 0x37, 0x8C, 0xDA, 0xE2, 0xB2, + 0xAB, 0xB4, 0x39, 0x3C, 0xC6, 0x7C, 0x7D, 0xD2, 0x91, 0xBE, 0x62, 0xF8, 0x4D, 0x01, 0x4E, 0xB4, + 0x3A, 0x19, 0xE2, 0x3E, 0x26, 0xD6, 0x2A, 0x55, 0x96, 0xC0, 0x0F, 0xA5, 0x35, 0x28, 0x0A, 0x5C, + 0xC1, 0x55, 0xD3, 0x72, 0x60, 0xF9, 0x65, 0xD0, 0xB2, 0x6C, 0x58, 0xAF, 0x8B, 0x00, 0x2B, 0x4C, + 0xF0, 0x4E, 0x8D, 0x15, 0x2F, 0xE5, 0x93, 0x05, 0x94, 0xF0, 0x02, 0x80, 0xDF, 0xFA, 0xEA, 0xA8, + 0xE8, 0x93, 0x50, 0xEB, 0xE1, 0x4D, 0x26, 0x34, 0xD3, 0x33, 0x83, 0x64, 0x30, 0x7D, 0x19, 0x51, + 0x50, 0x79, 0xF5, 0xF1, 0xD1, 0x2F, 0x7C, 0xC9, 0xF0, 0x3F, 0xF8, 0x60, 0x3B, 0x7E, 0x5D, 0x06, + 0x63, 0xED, 0x92, 0x0D, 0x0F, 0xD8, 0x9C, 0x6F, 0x74, 0x40, 0xF1, 0x40, 0xEC, 0x81, 0xAD, 0xAE, + 0xF0, 0xB2, 0x5E, 0x79, 0x71, 0x99, 0x89, 0x4F, 0xB9, 0xB2, 0x82, 0x15, 0x0D, 0x80, 0x7A, 0x68, + 0x13, 0x85, 0x4A, 0x6C, 0x6B, 0x1B, 0xD3, 0xA7, 0x67, 0x84, 0x14, 0xC5, 0xCE, 0xC9, 0xF2, 0x61, + 0x45, 0x7E, 0xEE, 0x7E, 0x6F, 0xD4, 0xB5, 0x15, 0xEE, 0x2C, 0x6C, 0xCC, 0x9D, 0x88, 0x38, 0x55, + 0x65, 0x78, 0xCF, 0x65, 0x8D, 0x2F, 0x22, 0xDD, 0xD9, 0x58, 0x9B, 0x60, 0x48, 0xEB, 0x96, 0xD5, + 0x17, 0xEE, 0x40, 0xFC, 0xA1, 0x9C, 0x70, 0x51, 0x2B, 0x0F, 0xCB, 0x80, 0x2C, 0x4A, 0x28, 0x4E, + 0x49, 0xAF, 0xA0, 0x6D, 0xA5, 0xF7, 0x58, 0x7E, 0x23, 0x30, 0xE9, 0x22, 0xE5, 0xC0, 0xD5, 0x65, + 0x13, 0xE6, 0xC1, 0x71, 0x94, 0xAF, 0xDE, 0x6A, 0x53, 0x4C, 0xDE, 0xB8, 0x35, 0xFE, 0x1F, 0xF0, + 0x51, 0x61, 0x5F, 0xC2, 0xA4, 0xA9, 0x66, 0x92, 0x93, 0x89, 0xC2, 0x4E, 0xDB, 0x7B, 0x9C, 0x11, + 0x62, 0xE5, 0xE6, 0xD7, 0x86, 0xD0, 0x8B, 0x33, 0x9E, 0x15, 0x78, 0x11, 0xF1, 0xC9, 0xA6, 0x4B, + 0xA9, 0xB8, 0x38, 0xDE, 0xB2, 0x55, 0xB6, 0x0E, 0xEF, 0x6E, 0xC9, 0xC8, 0x5A, 0x39, 0x1C, 0xEE, + 0x0F, 0x5C, 0x83, 0x2A, 0x46, 0x22, 0x4C, 0xA6, 0xD3, 0x38, 0xBA, 0x19, 0xA6, 0xB5, 0x70, 0x80, + 0xCF, 0x84, 0x6B, 0x02, 0x98, 0xAB, 0x4C, 0x48, 0x4F, 0xF2, 0x19, 0xDB, 0xBB, 0xB3, 0x1E, 0x21, + 0x41, 0xD2, 0x67, 0x16, 0x05, 0xC9, 0x21, 0x03, 0x3C, 0xC5, 0x7C, 0x0E, 0x85, 0xD8, 0x6F, 0x9D, + 0x57, 0x12, 0xE4, 0xC7, 0xCB, 0x73, 0xC3, 0xFE, 0xA3, 0x9E, 0xCD, 0x4D, 0x50, 0x4F, 0x4F, 0xDE, + 0x4A, 0x54, 0x17, 0x64, 0x6B, 0x13, 0x07, 0x7D, 0x48, 0x14, 0x92, 0x4D, 0x29, 0x1C, 0xF9, 0x4D, + 0xB9, 0xAE, 0x56, 0xF8, 0xF5, 0xCB, 0x8B, 0x8B, 0x0E, 0xD1, 0x91, 0xD5, 0xE5, 0xB9, 0x2B, 0xA5, + 0x1E, 0x55, 0x2C, 0xC3, 0x48, 0x31, 0x81, 0x7C, 0xD1, 0x36, 0x36, 0x52, 0x59, 0xC6, 0xCA, 0xEB, + 0x65, 0x8E, 0x89, 0x1A, 0x65, 0xC8, 0xF3, 0xC4, 0x67, 0x2B, 0x5A, 0xD3, 0xD4, 0x35, 0x01, 0x4A, + 0x2C, 0xA8, 0x7F, 0xA2, 0xC2, 0x52, 0xA1, 0x2C, 0xB2, 0x55, 0x7C, 0x5C, 0xF9, 0xC2, 0xD2, 0x77, + 0x5E, 0xF3, 0x31, 0xFD, 0xD7, 0x79, 0x8D, 0x0E, 0xE1, 0x37, 0x87, 0xC9, 0x47, 0x43, 0x4E, 0xA9, + 0x7D, 0x9E, 0x51, 0x83, 0x57, 0x15, 0x4E, 0x6A, 0x43, 0x1F, 0xC8, 0x83, 0xA3, 0x31, 0xE8, 0x19, + 0x7E, 0xC3, 0x0D, 0x2A, 0x3A, 0x15, 0x85, 0xBE, 0x16, 0xA3, 0x4C, 0xCD, 0xC6, 0x1A, 0xB1, 0x48, + 0xDB, 0x02, 0xED, 0xA6, 0xFF, 0x9B, 0xC2, 0x6E, 0x7C, 0x3B, 0xC6, 0xCC, 0x8F, 0x0C, 0xDB, 0xE0, + 0x11, 0x66, 0xDA, 0x0F, 0x85, 0x68, 0x25, 0x34, 0x7A, 0x7C, 0x4D, 0x13, 0x19, 0xA7, 0x37, 0xBA, + 0x1B, 0x8A, 0xBA, 0x99, 0x0B, 0x39, 0x7D, 0x37, 0xA6, 0x32, 0x81, 0xD3, 0x73, 0x21, 0x6E, 0x4A, + 0x32, 0x26, 0xC5, 0xE6, 0x8F, 0x33, 0x52, 0x48, 0x23, 0x4A, 0x21, 0xBD, 0xF9, 0x12, 0xC0, 0xFD, + 0xDC, 0x39, 0x1B, 0x4B, 0xCE, 0x56, 0x44, 0xC4, 0x9B, 0x9C, 0xF4, 0xBE, 0xC0, 0x9A, 0xFD, 0x28, + 0xA1, 0xB2, 0xAE, 0xA7, 0xFB, 0x31, 0xB6, 0xF6, 0x62, 0x68, 0xC9, 0x44, 0xCA, 0x0F, 0x51, 0xFF, + 0xCB, 0x7C, 0x67, 0xAE, 0xF4, 0xFD, 0xC0, 0x71, 0x50, 0x35, 0x65, 0xF3, 0x9C, 0x08, 0xA0, 0x1B, + 0x3B, 0x42, 0x69, 0x95, 0x42, 0x7A, 0xE3, 0x87, 0xF3, 0xD6, 0xE9, 0xA7, 0x22, 0x5B, 0x83, 0x0B, + 0x5B, 0xE9, 0x0A, 0x0A, 0xFA, 0x2D, 0x82, 0x42, 0x73, 0xDF, 0x76, 0xAF, 0xE6, 0xD3, 0x9D, 0xB1, + 0xA4, 0xD8, 0xB6, 0xC5, 0x5F, 0xC7, 0x98, 0xCC, 0x80, 0xA3, 0xB7, 0x67, 0xF4, 0x28, 0xA4, 0x98, + 0xB5, 0x5D, 0xB3, 0x0E, 0x77, 0xF4, 0xD0, 0x7E, 0xE2, 0x1C, 0xE2, 0x6B, 0xB4, 0x67, 0x42, 0x40, + 0xCB, 0x5A, 0x59, 0x43, 0x80, 0xA4, 0x92, 0xEC, 0xEB, 0x1E, 0xFB, 0x08, 0xFA, 0x17, 0xFE, 0x5E, + 0xF5, 0xD5, 0x1E, 0x12, 0xEB, 0xE8, 0x91, 0x78, 0x0E, 0x13, 0x67, 0xF9, 0x51, 0x0B, 0xBF, 0xA6, + 0x9B, 0x19, 0x26, 0x1D, 0xAE, 0xF7, 0x3A, 0xBB, 0xD7, 0x61, 0x62, 0xFA, 0xDB, 0x75, 0x26, 0x34, + 0xB7, 0xAF, 0x8C, 0xDD, 0xF5, 0xC1, 0x1C, 0x65, 0x23, 0xF2, 0xEC, 0x58, 0xA1, 0x9E, 0x82, 0x66, + 0x58, 0x4C, 0xF8, 0x44, 0x20, 0x87, 0x26, 0xCA, 0x09, 0xD6, 0xCD, 0x19, 0x4C, 0x39, 0x2A, 0x63, + 0xC8, 0xE2, 0x04, 0x18, 0x32, 0xBC, 0x87, 0x39, 0x7A, 0x0A, 0x59, 0xAA, 0xD5, 0xEB, 0xAE, 0x20, + 0x10, 0x9A, 0xBD, 0xB5, 0x14, 0xFC, 0x59, 0xCE, 0x86, 0x96, 0x42, 0x4A, 0xB0, 0xAE, 0xA5, 0x65, + 0x56, 0x34, 0x04, 0x13, 0x7C, 0xA0, 0x8B, 0x44, 0x11, 0xCE, 0xC3, 0x3C, 0x32, 0x56, 0xE4, 0xE0, + 0xFC, 0xAF, 0x7E, 0x89, 0xFB, 0x44, 0x4A, 0x34, 0x1C, 0x02, 0x7F, 0x69, 0xF1, 0x38, 0x8B, 0x3C, + 0x23, 0x54, 0x4A, 0xD8, 0xF5, 0x69, 0x70, 0xCA, 0x04, 0x99, 0x2A, 0xB0, 0x66, 0x22, 0x55, 0x14, + 0x82, 0x2A, 0x4B, 0x63, 0xA5, 0x05, 0x1E, 0x62, 0x49, 0x6B, 0xC1, 0x83, 0x6B, 0xA5, 0x74, 0xDD, + 0x20, 0x26, 0xAD, 0xDD, 0xD1, 0x37, 0x2C, 0x7E, 0x36, 0xE0, 0xBF, 0xC1, 0xEA, 0x37, 0x89, 0x5F, + 0x74, 0x6F, 0xAC, 0x05, 0x71, 0x94, 0x8D, 0x79, 0x1B, 0xAB, 0x03, 0xD9, 0x96, 0x9E, 0x40, 0x69, + 0x47, 0x23, 0x77, 0x35, 0x35, 0x60, 0x6C, 0xAA, 0x0B, 0x07, 0xC7, 0x64, 0xF7, 0x7F, 0x43, 0x6B, + 0x02, 0x69, 0x41, 0xCA, 0x1B, 0x51, 0xD9, 0x87, 0xEB, 0x36, 0xDD, 0x9E, 0xFF, 0xA1, 0x50, 0x6A, + 0x33, 0x5F, 0x25, 0x04, 0x97, 0x46, 0x99, 0x4D, 0xA4, 0x37, 0xD9, 0xA2, 0x23, 0x6E, 0x4C, 0x1B, + 0x36, 0xED, 0x9F, 0x09, 0x30, 0x26, 0xAB, 0x6F, 0x98, 0x0F, 0xF6, 0x13, 0x44, 0x4F, 0xF1, 0x61, + 0x73, 0x53, 0x39, 0x90, 0x88, 0xAE, 0x32, 0xC7, 0x33, 0x6B, 0x1A, 0xA1, 0xE8, 0x6F, 0x82, 0x99, + 0x73, 0x20, 0x44, 0xCF, 0x27, 0x17, 0xF8, 0x88, 0x19, 0x45, 0xD2, 0x41, 0x0A, 0xDB, 0x68, 0xA8, + 0x59, 0xBC, 0x73, 0xF7, 0xF1, 0x2D, 0x58, 0xBA, 0x60, 0x26, 0xA2, 0xB8, 0x93, 0x31, 0x32, 0xAB, + 0x13, 0xDE, 0x61, 0x0D, 0xD7, 0xA0, 0xFC, 0x44, 0x2A, 0xEE, 0xA3, 0xCF, 0x37, 0x17, 0xF9, 0xF8, + 0x63, 0x5A, 0x0C, 0x94, 0x78, 0x57, 0x24, 0xC0, 0x20, 0x12, 0xDA, 0xF0, 0x91, 0x22, 0x0D, 0x8E, + 0x3D, 0x48, 0xA0, 0x41, 0xFC, 0x65, 0x34, 0x0A, 0x4B, 0xE4, 0xFF, 0xEE, 0xB9, 0xF6, 0xD5, 0x48, + 0x60, 0xD1, 0x08, 0x75, 0x19, 0x7D, 0x23, 0xE6, 0x48, 0x80, 0xA4, 0x80, 0x72, 0x25, 0xE8, 0xF5, + 0x08, 0xFA, 0x70, 0xB5, 0x93, 0x6C, 0xA0, 0xFD, 0x28, 0xD4, 0xC6, 0xB5, 0xE3, 0x6D, 0x70, 0x6B, + 0x6D, 0x3F, 0x61, 0x01, 0xEB, 0xC9, 0xE7, 0xE1, 0x55, 0x67, 0x43, 0xE7, 0xBE, 0x1B, 0xE5, 0xA6, + 0xB7, 0x6C, 0x8F, 0x6D, 0xE4, 0x22, 0xCF, 0x8C, 0x6C, 0x67, 0xE6, 0xF3, 0xEC, 0x07, 0xB3, 0xE9, + 0x51, 0xBE, 0xBD, 0xC8, 0xCE, 0x67, 0xF2, 0x14, 0x7B, 0xDD, 0x8C, 0x70, 0x6E, 0x4C, 0x3E, 0x1E, + 0xA6, 0xCB, 0xD7, 0x4B, 0x0F, 0x61, 0x76, 0x39, 0x91, 0xE9, 0xD2, 0x43, 0x51, 0x8E, 0x86, 0x82, + 0x7B, 0xB2, 0xCD, 0xF6, 0x0E, 0x74, 0x0F, 0xA3, 0xD4, 0x25, 0xC2, 0x16, 0xCB, 0xFB, 0x8A, 0x2A, + 0x0B, 0xFA, 0xCF, 0xC0, 0x99, 0x38, 0x48, 0xCD, 0x87, 0xB6, 0x39, 0x74, 0x5C, 0x9F, 0x0A, 0x12, + 0xA7, 0x42, 0x1B, 0xF2, 0xBC, 0x9A, 0x38, 0x12, 0xA1, 0x5F, 0x64, 0x54, 0x2A, 0x0C, 0xFB, 0xF9, + 0xF0, 0xB3, 0x4B, 0xC5, 0xD1, 0xAE, 0x15, 0x52, 0x14, 0xDE, 0x91, 0x16, 0x38, 0xAF, 0x01, 0x16, + 0x8D, 0x29, 0x3E, 0xFE, 0x62, 0xF3, 0x57, 0x10, 0x6C, 0x21, 0x10, 0x9F, 0x8F, 0x4C, 0xF9, 0xE8, + 0x7F, 0x77, 0xFF, 0xF7, 0x01, 0x53, 0x7E, 0xB8, 0xC3, 0xFC, 0x88, 0xF1, 0xB1, 0x5A, 0x63, 0xAB, + 0xC2, 0x78, 0x8C, 0x15, 0x96, 0x61, 0xC7, 0x88, 0xC5, 0x45, 0x16, 0xE9, 0xE1, 0xD5, 0x77, 0xB4, + 0xC9, 0xA6, 0xAB, 0x47, 0xEE, 0x86, 0xFE, 0xD1, 0x2C, 0xAB, 0x23, 0x18, 0xA7, 0xB0, 0x4D, 0x18, + 0x52, 0xB7, 0xEF, 0x68, 0xCB, 0x80, 0xF9, 0x05, 0x15, 0x7A, 0xCB, 0x61, 0xC5, 0xCE, 0xCF, 0x92, + 0x3B, 0xCA, 0x7C, 0xEC, 0x02, 0x6F, 0x6B, 0x1E, 0x27, 0xAC, 0x07, 0xF2, 0x63, 0xB8, 0xDC, 0x1C, + 0x6A, 0x52, 0xB5, 0xF2, 0x90, 0xEB, 0x16, 0xA1, 0x2C, 0x9C, 0x3D, 0x20, 0x4B, 0xB3, 0xB9, 0x3B, + 0xD3, 0xE0, 0x7A, 0xCC, 0x9E, 0xF8, 0x95, 0x32, 0x2A, 0x34, 0x4A, 0xBC, 0x1E, 0x21, 0x05, 0x02, + 0x1A, 0xF4, 0x19, 0x32, 0x7B, 0x4A, 0x08, 0x15, 0x1B, 0xB1, 0xD5, 0x25, 0x53, 0x78, 0x99, 0xD8, + 0x9D, 0x8E, 0x45, 0xAE, 0x44, 0x52, 0x90, 0xC3, 0x89, 0xE7, 0xA5, 0x3E, 0xFA, 0xBC, 0x1C, 0x43, + 0x7B, 0x2E, 0x6B, 0x26, 0x84, 0x19, 0xA7, 0x4D, 0xDC, 0xD6, 0x4D, 0x29, 0x0F, 0x3A, 0xA5, 0xBC, + 0x09, 0x07, 0x53, 0x20, 0x8E, 0xE2, 0x91, 0x38, 0x73, 0x70, 0xA0, 0xAE, 0x10, 0xE0, 0x62, 0x49, + 0xAD, 0x71, 0x64, 0xC7, 0x8F, 0x15, 0x04, 0x42, 0xB4, 0xA6, 0x37, 0xEB, 0x9A, 0xB2, 0x00, 0x20, + 0xC6, 0x55, 0x3C, 0x14, 0xAB, 0xC2, 0x15, 0xF5, 0xB7, 0x79, 0x81, 0x5D, 0x36, 0xC2, 0xEC, 0xBA, + 0xC3, 0xB5, 0xAC, 0xF5, 0x2A, 0x92, 0x2A, 0xAC, 0x4D, 0x7F, 0x71, 0x5A, 0xFE, 0x74, 0xAC, 0xFE, + 0x70, 0x58, 0x9F, 0x61, 0x10, 0x95, 0xED, 0x04, 0xF7, 0x1E, 0x49, 0x99, 0xCD, 0xAB, 0x2C, 0x3A, + 0x8F, 0x00, 0x26, 0x48, 0x5F, 0x0F, 0x80, 0xFF, 0x72, 0x05, 0x82, 0xE4, 0xDD, 0x6F, 0x7C, 0xDA, + 0x42, 0x91, 0x94, 0x57, 0x8F, 0xC0, 0xA7, 0xBA, 0x46, 0x8C, 0x15, 0xE9, 0xEA, 0x5E, 0xCD, 0xE7, + 0x63, 0xB3, 0x15, 0x50, 0x5E, 0x71, 0x35, 0xEE, 0x84, 0xFA, 0x23, 0x4B, 0xEE, 0x5B, 0x99, 0xDF, + 0x0D, 0xE5, 0x69, 0xC7, 0xD7, 0xF7, 0x49, 0xC4, 0xEF, 0x19, 0x88, 0x57, 0xB5, 0x4F, 0x3E, 0x18, + 0xF9, 0x61, 0x1A, 0xFE, 0xFB, 0x15, 0xE3, 0x65, 0x49, 0x19, 0x17, 0xBA, 0xC0, 0x26, 0x8A, 0x5E, + 0x8D, 0x29, 0x50, 0x62, 0x19, 0x6E, 0xFA, 0x22, 0x7E, 0xEA, 0xE6, 0x2F, 0x90, 0xEF, 0x71, 0x21, + 0xAD, 0x2A, 0xFC, 0x97, 0xBA, 0xC7, 0x71, 0x7D, 0x68, 0x1C, 0x53, 0xB1, 0xD4, 0x59, 0xED, 0xE1, + 0x56, 0x54, 0xD1, 0x89, 0xC4, 0xB0, 0xB8, 0x88, 0x78, 0xCA, 0xF7, 0x85, 0x7E, 0xA0, 0xE8, 0xF4, + 0xE5, 0x12, 0xE8, 0x24, 0x9A, 0x51, 0xE9, 0xA3, 0x52, 0x96, 0x59, 0x47, 0x07, 0x63, 0xAE, 0x18, + 0x41, 0xAB, 0x17, 0xE8, 0x94, 0xDF, 0x94, 0x2F, 0x8F, 0x36, 0x34, 0x91, 0x20, 0x52, 0xE0, 0x11, + 0x2E, 0xFF, 0xBD, 0xBD, 0x6E, 0x49, 0xE2, 0x41, 0xA6, 0xD0, 0x10, 0xD0, 0x2C, 0xE4, 0x2E, 0x9F, + 0xBF, 0x36, 0xAD, 0xDA, 0xA5, 0xFE, 0xD9, 0xEC, 0xC1, 0x55, 0x20, 0xCB, 0x10, 0xAD, 0x4D, 0xE3, + 0xD2, 0xE7, 0x09, 0xFB, 0x14, 0xC2, 0x11, 0x33, 0x2C, 0xFA, 0xDE, 0x82, 0x15, 0x4D, 0xF0, 0xB6, + 0x71, 0x3C, 0x58, 0x80, 0xD2, 0x87, 0x05, 0x89, 0xEF, 0x00, 0x6C, 0x8A, 0xFB, 0x14, 0xF3, 0x65, + 0x22, 0xCD, 0xBF, 0x25, 0x03, 0x60, 0x12, 0x38, 0x2B, 0x0A, 0xF1, 0xFB, 0xCB, 0x80, 0x11, 0x3B, + 0x59, 0xE2, 0xEF, 0x07, 0xC8, 0x97, 0x50, 0xFE, 0x56, 0x4C, 0x52, 0x4F, 0x73, 0xD9, 0xCA, 0x89, + 0x7B, 0xEA, 0x50, 0x5E, 0xCB, 0xB9, 0xEE, 0xC8, 0xFF, 0xC5, 0x13, 0x62, 0x00, 0x9F, 0xBF, 0x61, + 0xC7, 0x2F, 0x0F, 0xBF, 0x75, 0xC3, 0x0E, 0x72, 0x2C, 0xF7, 0xDF, 0xA5, 0xAE, 0x94, 0x15, 0x8F, + 0xBB, 0x1D, 0x26, 0xA0, 0xCB, 0x8B, 0x40, 0x78, 0x48, 0xB4, 0x41, 0x47, 0x6B, 0x7D, 0x45, 0xBE, + 0x39, 0xA5, 0xE2, 0xB7, 0x11, 0xEF, 0xE8, 0x19, 0xA0, 0x62, 0x26, 0xE1, 0xD5, 0x94, 0x54, 0x9D, + 0xA4, 0x28, 0xEE, 0x7F, 0x7F, 0x25, 0xAD, 0xDB, 0x28, 0x2C, 0xDB, 0xA7, 0x63, 0xF8, 0x0E, 0x6E, + 0xE2, 0x0F, 0x8F, 0xC7, 0x17, 0x31, 0xB2, 0x8D, 0xA8, 0x92, 0x7A, 0x81, 0xD5, 0x88, 0x2E, 0xD3, + 0xF2, 0xE5, 0x08, 0x76, 0xC7, 0x93, 0xDB, 0xC0, 0x0B, 0x38, 0x58, 0xF7, 0x6F, 0xC4, 0x58, 0xAD, + 0xB0, 0x3B, 0xDC, 0xE6, 0xD1, 0xB3, 0xC2, 0x39, 0x25, 0xE7, 0x48, 0x19, 0xC8, 0x27, 0xD1, 0xDF, + 0x9F, 0x5F, 0xB8, 0x5A, 0x50, 0xE9, 0x0B, 0x51, 0x43, 0x2C, 0xA6, 0x09, 0x39, 0x14, 0xF5, 0x3E, + 0x03, 0x6E, 0x55, 0x7D, 0xE3, 0x42, 0xE5, 0xBB, 0x40, 0xA0, 0x71, 0xAA, 0xF1, 0xAF, 0x6E, 0xF2, + 0xE2, 0x59, 0x94, 0xF2, 0x9F, 0x79, 0x67, 0x23, 0x6F, 0xCA, 0x85, 0xF6, 0x1F, 0xA3, 0x87, 0x7B, + 0xE6, 0x62, 0xEE, 0x8F, 0x0D, 0x48, 0x89, 0x98, 0x37, 0x35, 0x91, 0x05, 0x58, 0xA3, 0x83, 0x28, + 0x13, 0xA2, 0x1E, 0xD1, 0x49, 0x5F, 0x68, 0x59, 0x47, 0x49, 0xED, 0x7B, 0xC2, 0x45, 0x58, 0xCB, + 0xB7, 0xC8, 0x91, 0x3B, 0xF5, 0xB4, 0xC4, 0x8C, 0x01, 0xE3, 0x78, 0x3A, 0x3D, 0xD9, 0x58, 0x0B, + 0xA3, 0xB2, 0x8C, 0xFA, 0xF1, 0x8C, 0xC5, 0x77, 0x93, 0xC9, 0x88, 0x80, 0x67, 0xB5, 0x62, 0x55, + 0x6E, 0x01, 0x74, 0xF3, 0x81, 0x9E, 0xAE, 0x27, 0xB0, 0x20, 0xC6, 0xE1, 0xAE, 0xE7, 0xBB, 0x8D, + 0x12, 0x27, 0x6D, 0x23, 0xF3, 0x1D, 0xCD, 0x5E, 0x20, 0xAC, 0x10, 0x06, 0x1D, 0x3C, 0xB4, 0x86, + 0xB7, 0x0E, 0x8C, 0x9D, 0x14, 0xD5, 0xAC, 0xFF, 0xFE, 0xE5, 0x6B, 0xEB, 0xED, 0x3F, 0xF5, 0x40, + 0xBA, 0x69, 0x66, 0x90, 0xFA, 0x54, 0xAC, 0xB9, 0xCB, 0x07, 0x38, 0xAF, 0xE4, 0x40, 0x41, 0x0C, + 0x0A, 0x44, 0x2D, 0x31, 0x46, 0x4E, 0x2B, 0x75, 0xFA, 0x06, 0xA3, 0x59, 0xC3, 0x27, 0x53, 0xFC, + 0xB6, 0xEF, 0xBA, 0x10, 0xAA, 0x65, 0x1D, 0x1C, 0xAB, 0x19, 0x8C, 0x54, 0x1D, 0x3B, 0xBB, 0x10, + 0x05, 0xAA, 0xAE, 0xEF, 0x80, 0x03, 0x28, 0xA7, 0x4D, 0xA9, 0xD8, 0xA8, 0x34, 0x75, 0xC6, 0x2B, + 0x43, 0x82, 0x59, 0x00, 0x2E, 0xEE, 0xF9, 0x8A, 0x8F, 0x8E, 0x1C, 0x21, 0xA0, 0xDC, 0xAA, 0xFC, + 0xBF, 0x15, 0x2F, 0x6D, 0x00, 0x33, 0x81, 0x24, 0x86, 0x58, 0xCF, 0xD5, 0x5A, 0xC4, 0xB3, 0x28, + 0x97, 0xC5, 0x45, 0xAB, 0x8D, 0x48, 0xDE, 0xEA, 0xB2, 0xFD, 0x1E, 0xD3, 0x13, 0x57, 0xFF, 0xFB, + 0x24, 0xDE, 0x7A, 0x9D, 0x43, 0xF8, 0xC7, 0xDD, 0x1A, 0x28, 0x7C, 0x39, 0xA4, 0xDA, 0x58, 0xB7, + 0xBD, 0x1D, 0x24, 0xDE, 0xCF, 0x85, 0x7E, 0xEF, 0x5A, 0x4F, 0xF1, 0xB4, 0xCB, 0xA6, 0x5E, 0xC0, + 0x80, 0xE6, 0x0B, 0xC0, 0x69, 0xAD, 0x5D, 0xB4, 0x88, 0xBD, 0xFB, 0x78, 0x2C, 0x3C, 0xA6, 0x69, + 0x77, 0x16, 0xD6, 0xA9, 0xFF, 0x4A, 0x6C, 0xC0, 0x48, 0x27, 0x64, 0x41, 0x51, 0x79, 0xC6, 0xF9, + 0x85, 0x71, 0x9C, 0x89, 0xD2, 0x68, 0xF5, 0xBB, 0xE5, 0x83, 0xF5, 0xD0, 0xEB, 0x25, 0xC7, 0x1E, + 0x50, 0xA8, 0x1F, 0x50, 0x86, 0xEE, 0x1F, 0xE9, 0x4A, 0xB3, 0xA0, 0x18, 0xF8, 0xCE, 0xD6, 0x0B, + 0xF2, 0x41, 0xFC, 0x21, 0x20, 0x1A, 0xA3, 0x9D, 0xB7, 0xD1, 0x49, 0x79, 0xE2, 0x7B, 0xF3, 0x8B, + 0x40, 0x6F, 0xE2, 0x45, 0x00, 0x5A, 0x81, 0x7D, 0x39, 0x93, 0x3B, 0x59, 0xE0, 0x3E, 0xCA, 0xC5, + 0x61, 0x80, 0x65, 0x2D, 0xC9, 0xAD, 0x2C, 0x26, 0x66, 0x11, 0x3A, 0xA6, 0xBA, 0xF5, 0x3B, 0x49, + 0xC5, 0xB1, 0xAA, 0xB6, 0xBC, 0x68, 0x00, 0x51, 0x82, 0x1A, 0x39, 0x2B, 0x28, 0x5C, 0x39, 0xF2, + 0xB4, 0x7E, 0x93, 0x63, 0xEA, 0xD7, 0xBE, 0x7F, 0xA0, 0xCC, 0x47, 0x31, 0x2E, 0xBA, 0x9C, 0xD0, + 0x67, 0xBF, 0xE0, 0xDE, 0x46, 0xCA, 0xA1, 0x84, 0x57, 0x6B, 0x15, 0x0A, 0xC6, 0xAB, 0x32, 0x74, + 0x37, 0x34, 0xDA, 0x1A, 0x95, 0xA6, 0xA4, 0xEE, 0xF6, 0xC6, 0xFB, 0x70, 0x56, 0x0C, 0xC4, 0xCA, + 0x0D, 0xD5, 0xCB, 0x03, 0xA3, 0x21, 0xF5, 0x6D, 0x0F, 0xD1, 0xEE, 0x77, 0x73, 0xA4, 0xF9, 0x95, + 0x34, 0x2F, 0x0C, 0x5B, 0x7F, 0x48, 0x6A, 0x02, 0x4A, 0xA4, 0x59, 0x68, 0x0F, 0xF4, 0x64, 0x73, + 0x84, 0xCE, 0xED, 0x43, 0x54, 0x46, 0xD9, 0x42, 0x4C, 0x84, 0xD5, 0xFE, 0x5B, 0xD3, 0x51, 0x17, + 0x4E, 0xB8, 0x7A, 0x42, 0x87, 0x45, 0xDB, 0xC3, 0x2C, 0xC8, 0x8B, 0x86, 0xB3, 0x95, 0x0B, 0xCF, + 0x27, 0xC4, 0xA8, 0xEE, 0x60, 0x13, 0xD3, 0x9F, 0xFC, 0xD0, 0x7F, 0x84, 0x5B, 0x24, 0x5D, 0xCF, + 0xE4, 0xA4, 0x83, 0x35, 0xD1, 0x7A, 0x72, 0x78, 0xB6, 0xB4, 0xA2, 0x32, 0x0F, 0x68, 0x61, 0x7C, + 0xB7, 0x46, 0x20, 0x1A, 0xA5, 0x94, 0x63, 0x71, 0xAA, 0xA0, 0x77, 0x95, 0x28, 0x63, 0xCE, 0xFE, + 0x69, 0xB6, 0x44, 0x10, 0xF6, 0xC1, 0xD7, 0xED, 0x11, 0x73, 0x9E, 0x46, 0xDE, 0xC3, 0xFF, 0x9E, + 0xB9, 0xEC, 0xEC, 0xE4, 0xE3, 0xFD, 0x1E, 0xD3, 0x55, 0x08, 0x36, 0xC8, 0xDC, 0xD1, 0x0E, 0x00, + 0xEE, 0x86, 0x78, 0x08, 0xB7, 0xAD, 0xD8, 0xE1, 0x59, 0x60, 0x33, 0x14, 0xF4, 0x5C, 0x55, 0xA4, + 0xF1, 0x0D, 0x0E, 0x16, 0xCD, 0x1C, 0x72, 0x6D, 0x89, 0xEB, 0x41, 0x42, 0xB1, 0xF5, 0x63, 0x80, + 0xD6, 0x06, 0xC3, 0x1C, 0xBE, 0x7B, 0x95, 0x2A, 0x5B, 0x27, 0x08, 0xDC, 0xB7, 0x2A, 0xDC, 0x8E, + 0x3C, 0xA0, 0x84, 0x5F, 0xA8, 0xF1, 0x7B, 0x1F, 0xE1, 0x70, 0x37, 0x2D, 0x28, 0xDC, 0x7C, 0xB8, + 0xA7, 0x47, 0x60, 0x77, 0xAC, 0x55, 0xE3, 0x97, 0x5A, 0xC1, 0xA6, 0xA2, 0xFF, 0xCB, 0xF6, 0x45, + 0x28, 0x1E, 0xD2, 0x1C, 0xE8, 0x9E, 0x45, 0xF7, 0x1E, 0xD5, 0x92, 0xB4, 0x5A, 0x5E, 0x6A, 0xE0, + 0xF7, 0x1A, 0x81, 0xD7, 0x96, 0x62, 0xB5, 0xD9, 0xE7, 0x0E, 0x3A, 0xA3, 0xE8, 0x60, 0x30, 0x45, + 0x96, 0x86, 0x58, 0xDD, 0xBA, 0x04, 0x5E, 0xF4, 0x5D, 0xE3, 0x82, 0x7D, 0x3B, 0xD5, 0xD6, 0x28, + 0xFF, 0xC6, 0xDE, 0x3A, 0x3D, 0xF8, 0xB5, 0x6A, 0x5A, 0x1D, 0x34, 0x63, 0x48, 0x6F, 0xE9, 0xC8, + 0x5F, 0x56, 0x17, 0x14, 0x56, 0xC7, 0xE4, 0xC2, 0x38, 0x68, 0x8A, 0x81, 0x0F, 0x4D, 0x4A, 0x91, + 0x79, 0x85, 0x40, 0xB1, 0x7A, 0xA5, 0x4A, 0xF1, 0xC2, 0xA2, 0x3B, 0x62, 0x4D, 0xD8, 0xD8, 0x41, + 0x80, 0x66, 0x48, 0x7A, 0x96, 0xF7, 0xB2, 0x05, 0xDC, 0xB2, 0xD7, 0xBF, 0xB8, 0xB3, 0x0C, 0xD5, + 0x12, 0x90, 0xBA, 0x86, 0xDB, 0x2D, 0x2D, 0x2F, 0x1A, 0xBE, 0xA8, 0xF0, 0x42, 0xA1, 0xE6, 0x9B, + 0x89, 0x57, 0x69, 0xFD, 0x1B, 0x18, 0x94, 0xC2, 0xE1, 0x53, 0xD3, 0xAD, 0x2D, 0x90, 0x8B, 0xEA, + 0xAB, 0x29, 0x47, 0x08, 0xE6, 0x4B, 0xAC, 0x3A, 0xFC, 0x8C, 0x40, 0xC3, 0x45, 0xD9, 0xCF, 0x24, + 0xA9, 0x17, 0xC4, 0xAD, 0x46, 0xAC, 0x27, 0xAD, 0xE6, 0xEE, 0xF2, 0xF7, 0x5F, 0x6C, 0xD7, 0xE7, + 0xF2, 0x01, 0xED, 0x98, 0x4E, 0x7A, 0x03, 0x94, 0x4C, 0x26, 0x69, 0x5E, 0x8D, 0xDC, 0x13, 0xD6, + 0x3A, 0x2D, 0x4A, 0x70, 0x0E, 0x39, 0x94, 0x63, 0xDE, 0x08, 0x7A, 0x72, 0x4D, 0xFE, 0x89, 0xCA, + 0x8C, 0x4D, 0x39, 0x6A, 0x99, 0xAD, 0xAC, 0xE7, 0x8F, 0x6E, 0xD2, 0x18, 0x98, 0xF4, 0x1B, 0xD7, + 0x0A, 0x60, 0xA2, 0x00, 0x1B, 0xB3, 0xE6, 0x37, 0xA1, 0x1F, 0x30, 0xBD, 0xFD, 0xA8, 0x58, 0xB7, + 0xFF, 0xF1, 0x45, 0x74, 0x9B, 0xE9, 0xA8, 0x80, 0x12, 0x0F, 0x98, 0xF7, 0x9E, 0x62, 0xF5, 0x4A, + 0x0C, 0x32, 0x58, 0x87, 0x65, 0x2D, 0xE4, 0x90, 0x44, 0xB2, 0xB1, 0x8A, 0xFB, 0x29, 0x99, 0x3C, + 0xE8, 0xEB, 0x4F, 0x99, 0x21, 0x47, 0x0D, 0xAA, 0x9F, 0x54, 0xAA, 0xFC, 0x47, 0xB6, 0x35, 0xFE, + 0x24, 0x73, 0xC2, 0x26, 0x18, 0x1E, 0x61, 0x18, 0xC7, 0xF5, 0xE1, 0xD9, 0x5C, 0x7E, 0xCA, 0x71, + 0xA5, 0xA6, 0x4D, 0x91, 0xC0, 0xC5, 0x0C, 0x65, 0x98, 0x69, 0x9B, 0x51, 0xDF, 0xC2, 0x88, 0x51, + 0x21, 0x49, 0x8D, 0x23, 0x52, 0x27, 0xAD, 0x83, 0xD7, 0xB3, 0x73, 0x34, 0x90, 0xD3, 0xA7, 0xDE, + 0x9D, 0x8C, 0x5F, 0xCA, 0xA6, 0x2C, 0x95, 0x01, 0xCC, 0x24, 0x59, 0x70, 0x74, 0xBB, 0x72, 0xD7, + 0x80, 0x25, 0x03, 0xD1, 0xB2, 0x0A, 0xF8, 0x0A, 0x53, 0x9E, 0x03, 0x6F, 0xA4, 0xFB, 0x20, 0x52, + 0x46, 0x0C, 0x2B, 0xD8, 0x25, 0x4D, 0xE8, 0xBA, 0xB7, 0x97, 0x8E, 0x77, 0x52, 0xA6, 0x18, 0x92, + 0xBE, 0x86, 0x89, 0x0B, 0x57, 0xBD, 0xBE, 0xAC, 0x74, 0xE5, 0x64, 0xEA, 0x0C, 0xEE, 0xA2, 0x70, + 0x09, 0x0A, 0x07, 0x97, 0xCD, 0x42, 0xD1, 0x91, 0x7E, 0x7F, 0xDE, 0xF5, 0x06, 0xBA, 0xBB, 0x91, + 0xF5, 0x90, 0x4D, 0x67, 0xDF, 0x02, 0x94, 0x7C, 0xAE, 0xC8, 0xD9, 0x80, 0x20, 0xF2, 0xFE, 0xA9, + 0x1B, 0x91, 0x34, 0x34, 0x18, 0xFE, 0xF2, 0xD1, 0xD2, 0xB6, 0xE4, 0xA6, 0x77, 0xD3, 0x63, 0x2C, + 0x82, 0x8A, 0xE0, 0x87, 0xEB, 0x30, 0xC5, 0x14, 0x7E, 0x55, 0x0E, 0x87, 0x7F, 0xD3, 0x5B, 0x88, + 0xA9, 0xA7, 0x1B, 0xB8, 0x55, 0xE1, 0x60, 0x1B, 0xF3, 0x09, 0x8D, 0xE4, 0x31, 0xFF, 0xAA, 0xB0, + 0xFC, 0x29, 0xD2, 0x3F, 0xEE, 0x8C, 0x99, 0x0B, 0x79, 0x1F, 0x60, 0x6F, 0xF7, 0xE0, 0x5A, 0x5E, + 0xD2, 0xB2, 0x52, 0x6C, 0xD4, 0xF5, 0x96, 0x76, 0xAC, 0x51, 0x07, 0xA0, 0xEC, 0x01, 0x34, 0x37, + 0xDB, 0xB0, 0xBE, 0x04, 0x2C, 0x1D, 0xCF, 0x1C, 0x8B, 0xF4, 0xAE, 0x03, 0x7A, 0x9C, 0x6A, 0xDA, + 0xC6, 0xD7, 0xB2, 0xE8, 0x9C, 0x2D, 0xCB, 0x42, 0x7C, 0xFA, 0x49, 0x3E, 0xCA, 0x93, 0xA3, 0x2E, + 0x34, 0x16, 0x35, 0xC7, 0xEB, 0x14, 0x65, 0x95, 0xDD, 0x50, 0x3F, 0xE2, 0xA7, 0xB8, 0x31, 0x30, + 0x19, 0xC5, 0x39, 0xE6, 0xD6, 0xD8, 0xCB, 0x8B, 0x35, 0x85, 0xB9, 0x2F, 0x5F, 0x72, 0x38, 0xA0, + 0x32, 0x7D, 0x0B, 0x30, 0x69, 0x4E, 0xEB, 0x97, 0x1B, 0x5A, 0xCC, 0xCB, 0x9F, 0x14, 0xD1, 0xC4, + 0x66, 0x03, 0xE3, 0xC9, 0xC8, 0x70, 0xD0, 0x08, 0xE6, 0x1B, 0x08, 0xEF, 0xB2, 0x13, 0xF3, 0xAE, + 0x61, 0x5E, 0xE2, 0xF9, 0x72, 0x7B, 0x20, 0x63, 0x86, 0x8A, 0x3A, 0xBD, 0xFB, 0x08, 0xA9, 0x90, + 0xA6, 0xFF, 0xC4, 0xF7, 0xDA, 0x6D, 0x2C, 0x96, 0x5F, 0xB8, 0xE0, 0x73, 0x7C, 0x92, 0xA1, 0xE5, + 0xF9, 0x10, 0x01, 0x6F, 0xCD, 0xFF, 0x16, 0xCE, 0x54, 0x2E, 0x16, 0x87, 0x65, 0xA4, 0xB1, 0xD4, + 0xA2, 0x7E, 0xD2, 0x09, 0xC5, 0x97, 0x7C, 0xDA, 0xAC, 0x7B, 0xA4, 0xA1, 0x0A, 0xD3, 0x84, 0x1E, + 0xEA, 0xE3, 0x8E, 0xA3, 0xB2, 0x30, 0x23, 0x84, 0x51, 0x0C, 0x78, 0x43, 0x46, 0x86, 0xF0, 0x10, + 0xED, 0xF6, 0x57, 0xA7, 0x40, 0x33, 0xCC, 0x19, 0xC6, 0xB7, 0xFA, 0x45, 0x7C, 0x22, 0x26, 0x07, + 0x0F, 0xC7, 0x6E, 0x86, 0xB7, 0x71, 0xA4, 0xC3, 0x1E, 0x54, 0x9F, 0xAF, 0x84, 0x94, 0xEB, 0x84, + 0x6E, 0xE8, 0xDE, 0xA6, 0xC8, 0xA6, 0xBB, 0x93, 0xF6, 0x06, 0x1B, 0x49, 0x82, 0x06, 0x01, 0xAC, + 0x6A, 0x69, 0x9C, 0x44, 0xC2, 0xFF, 0x84, 0xA0, 0xDD, 0x87, 0xD2, 0xF7, 0xFB, 0xF8, 0x05, 0x14, + 0x59, 0x3F, 0x6B, 0x68, 0x90, 0x11, 0x78, 0x8F, 0xA1, 0x6F, 0x0F, 0x7B, 0x62, 0x47, 0xD0, 0xB1, + 0xBB, 0x80, 0x7D, 0x3C, 0x1F, 0x09, 0x7B, 0xE9, 0x60, 0x32, 0x78, 0xB1, 0xE6, 0x1B, 0xD0, 0x9C, + 0x9D, 0xA5, 0x56, 0x47, 0xB7, 0x47, 0x4B, 0x42, 0xCA, 0xBA, 0x34, 0x40, 0x30, 0xE4, 0x80, 0x9F, + 0x74, 0xD9, 0x4F, 0x64, 0x4B, 0x3F, 0x7C, 0x04, 0x76, 0x45, 0x1C, 0x58, 0xA2, 0xC8, 0x5C, 0xC6, + 0x08, 0x5B, 0xD2, 0x80, 0x58, 0xC1, 0x22, 0x3F, 0x9C, 0x99, 0xCD, 0xB8, 0x4A, 0xF6, 0x3E, 0xD4, + 0xFF, 0x26, 0x4C, 0xBF, 0xD5, 0xA0, 0x38, 0x40, 0x30, 0x1D, 0x04, 0x9A, 0xE0, 0x8C, 0x04, 0x6A, + 0x87, 0xB6, 0x16, 0x3F, 0x0C, 0xF9, 0xC5, 0x85, 0x43, 0x77, 0x50, 0x9B, 0xF8, 0x75, 0xA3, 0x9A, + 0xAD, 0x2A, 0x1D, 0x7C, 0xF9, 0xD3, 0x00, 0x7D, 0xFC, 0xA8, 0x5F, 0x7C, 0xC8, 0xEB, 0x69, 0xC4, + 0xAC, 0x16, 0xEB, 0xED, 0x53, 0xBE, 0x66, 0x95, 0xFC, 0x81, 0x65, 0x17, 0x65, 0xEB, 0x0B, 0x7F, + 0xF7, 0x57, 0x35, 0x50, 0x43, 0xBB, 0xC5, 0x1A, 0xC9, 0xA2, 0xCF, 0x7B, 0x1D, 0xC0, 0x9E, 0x02, + 0x79, 0x29, 0x23, 0xB6, 0x24, 0xCF, 0x55, 0x5A, 0x52, 0x3A, 0x51, 0xCE, 0x03, 0xB9, 0x0F, 0xF7, + 0x45, 0x5F, 0x10, 0xE7, 0x78, 0xD6, 0x2B, 0xF8, 0xD0, 0x8C, 0x7F, 0xE8, 0xA1, 0xA5, 0x7F, 0x07, + 0x51, 0xE4, 0xF6, 0xB8, 0xC4, 0xB5, 0xF1, 0xC4, 0xC0, 0x18, 0x2A, 0xD2, 0xC3, 0x86, 0xB9, 0xB1, + 0x35, 0xD8, 0xDD, 0xD3, 0x77, 0x73, 0xAB, 0x01, 0x4A, 0xDE, 0x76, 0x5F, 0x3C, 0x6E, 0x56, 0xB3, + 0x82, 0xC3, 0x7B, 0x03, 0x81, 0x29, 0x7F, 0xE0, 0x83, 0x40, 0xF4, 0x52, 0xF5, 0x32, 0x6A, 0x12, + 0x32, 0x84, 0xBE, 0xBE, 0x92, 0xDA, 0x04, 0x32, 0x40, 0xCF, 0x13, 0xE8, 0x5E, 0x6D, 0x79, 0x71, + 0x5C, 0x98, 0x8C, 0x83, 0xEE, 0x37, 0xE2, 0x65, 0xAA, 0x83, 0xF9, 0xD5, 0xD8, 0xDF, 0x5B, 0x70, + 0x46, 0x64, 0xAB, 0xAA, 0x16, 0x53, 0x66, 0x4B, 0x7F, 0xA6, 0x79, 0x24, 0xBC, 0xD5, 0x35, 0xEF, + 0x14, 0xF6, 0xEA, 0x75, 0xF1, 0xD3, 0x41, 0x18, 0x44, 0x58, 0xD8, 0xA0, 0x49, 0x52, 0x99, 0x7B, + 0x25, 0x6B, 0x65, 0x4B, 0x1B, 0xC7, 0x1D, 0xFB, 0x87, 0x27, 0x8D, 0x3B, 0xBD, 0xC1, 0xF7, 0xD3, + 0x51, 0xED, 0x7F, 0x43, 0xB6, 0x23, 0xC2, 0x70, 0x61, 0xB3, 0xB0, 0x0D, 0xB2, 0xE9, 0x58, 0x5E, + 0xFA, 0x23, 0xD1, 0xC7, 0x06, 0x76, 0xBF, 0x48, 0x06, 0xF4, 0xF9, 0xFC, 0x1C, 0x6F, 0xD6, 0xF8, + 0xFF, 0x9E, 0x40, 0xCF, 0xAD, 0xB7, 0x95, 0xF7, 0x2C, 0x5B, 0xD2, 0xD5, 0x49, 0xA3, 0xAB, 0xCA, + 0x3E, 0x5B, 0xB0, 0x8B, 0x2E, 0x70, 0x27, 0x7D, 0x36, 0x88, 0xB5, 0x25, 0xBA, 0xE9, 0x67, 0x62, + 0xB0, 0xA8, 0x26, 0x8C, 0xA4, 0xB7, 0x14, 0xAE, 0xEC, 0xF1, 0x0D, 0xF1, 0x3E, 0xFC, 0x76, 0x5A, + 0x27, 0x32, 0x60, 0xBE, 0x71, 0x74, 0xE2, 0x54, 0x66, 0xC1, 0xAF, 0x6E, 0xBD, 0x11, 0x3A, 0x1F, + 0x0A, 0x0B, 0xF5, 0x61, 0x04, 0xF3, 0x0A, 0x2B, 0x8B, 0x90, 0x8F, 0x82, 0x42, 0x03, 0x18, 0x1B, + 0xC5, 0x08, 0x53, 0xB9, 0x53, 0x35, 0xB1, 0x05, 0x9F, 0x05, 0x59, 0x85, 0x2C, 0x25, 0x48, 0xD3, + 0x2C, 0xB6, 0xFE, 0xF8, 0x3B, 0x08, 0x49, 0xF3, 0xC1, 0x56, 0x87, 0x49, 0xEB, 0x4D, 0x05, 0x1F, + 0xE5, 0x0F, 0xB5, 0x99, 0xDA, 0xBF, 0x78, 0xC9, 0xFA, 0x1F, 0x62, 0x66, 0x4B, 0xB8, 0x76, 0xAF, + 0x69, 0xDD, 0x4A, 0x80, 0x52, 0x58, 0xB2, 0x04, 0x0B, 0x87, 0x66, 0xF9, 0xE2, 0xF0, 0x66, 0x15, + 0x7F, 0x4C, 0x40, 0x6B, 0x4A, 0xD6, 0x47, 0xD8, 0x81, 0xF1, 0x3B, 0xEF, 0x5C, 0xF7, 0x10, 0x7D, + 0x5C, 0xBC, 0x53, 0x11, 0xFF, 0x8B, 0x6D, 0x4C, 0x08, 0x16, 0x47, 0x48, 0xF2, 0xA0, 0x2C, 0xEF, + 0x33, 0x31, 0x90, 0x94, 0x45, 0x66, 0xC8, 0x3F, 0x84, 0x11, 0xDA, 0x8C, 0xD7, 0x90, 0x8F, 0xF0, + 0x3D, 0xF2, 0xBB, 0x86, 0xFF, 0x90, 0xF3, 0xFB, 0x52, 0xF5, 0x60, 0x3E, 0xF3, 0xBD, 0xAC, 0x3A, + 0x6C, 0x74, 0x7D, 0x03, 0x85, 0xB6, 0xFA, 0xA4, 0x75, 0xD6, 0x52, 0xDB, 0xD2, 0xB8, 0x30, 0xF1, + 0x78, 0x7B, 0xCF, 0xC5, 0x57, 0xDF, 0x52, 0xB9, 0xEF, 0xC5, 0xEF, 0xCA, 0x6D, 0x38, 0x0E, 0x28, + 0xC4, 0x9D, 0x93, 0x4D, 0x73, 0x0A, 0xD1, 0x11, 0xAD, 0x33, 0x27, 0xC9, 0x7E, 0xF8, 0x85, 0x1D, + 0x05, 0x41, 0x6A, 0xAA, 0x6A, 0xA5, 0xBE, 0xD0, 0x93, 0x05, 0x8A, 0x73, 0xF2, 0xF0, 0x61, 0x94, + 0x25, 0xF0, 0xA9, 0x12, 0x12, 0xD8, 0xFF, 0xB1, 0xF0, 0x06, 0xA5, 0x47, 0x69, 0x15, 0xCC, 0xE9, + 0x6B, 0x9D, 0x6E, 0xD9, 0x96, 0xA7, 0xEF, 0x9D, 0x75, 0x9A, 0xD0, 0xD7, 0x90, 0xFE, 0xAF, 0xEB, + 0xC1, 0xBA, 0x83, 0x48, 0x46, 0x54, 0x7C, 0x86, 0x4B, 0x45, 0x4B, 0xA6, 0xE4, 0x3A, 0x33, 0x52, + 0xFD, 0xAF, 0x45, 0x92, 0xF4, 0xB0, 0x88, 0x62, 0x28, 0x9D, 0x52, 0x14, 0xBE, 0x5F, 0xD8, 0xCB, + 0x32, 0x69, 0xC8, 0xB3, 0xB3, 0x27, 0xE4, 0xDC, 0x85, 0xCD, 0x3D, 0x84, 0x51, 0xC1, 0xB6, 0x1F, + 0x50, 0x9F, 0x80, 0x9B, 0xF2, 0xA8, 0xCE, 0x59, 0xAF, 0x25, 0xA7, 0x5A, 0xD6, 0x23, 0xDA, 0xFF, + 0xDC, 0x0A, 0xF1, 0xF8, 0x93, 0x1D, 0xE3, 0x00, 0x90, 0x64, 0x91, 0xCF, 0xEC, 0xDC, 0x40, 0xB8, + 0x64, 0x10, 0xBC, 0x1E, 0x07, 0xF6, 0x98, 0xC1, 0xDE, 0x1B, 0xF3, 0x7D, 0x3A, 0x63, 0x2D, 0x82, + 0xD0, 0x55, 0x0A, 0x45, 0x3F, 0x12, 0x9D, 0xF1, 0x97, 0x9E, 0x5C, 0xAD, 0x2F, 0x1E, 0x36, 0x13, + 0x56, 0xFC, 0xEF, 0xF5, 0x59, 0x9A, 0x2B, 0xE5, 0x99, 0xBB, 0x58, 0xD8, 0x18, 0xD4, 0xB0, 0x0C, + 0x6E, 0x84, 0x7A, 0x50, 0x4C, 0x37, 0x52, 0x32, 0x77, 0xE8, 0x4D, 0x4B, 0x98, 0x42, 0x74, 0x98, + 0x92, 0x42, 0xA9, 0x38, 0x78, 0xBE, 0x51, 0xC0, 0x87, 0x66, 0x5B, 0x20, 0x1C, 0xBC, 0xE6, 0x60, + 0xA4, 0x4F, 0x19, 0x13, 0x61, 0x5E, 0x85, 0x3B, 0xE4, 0xC6, 0x98, 0xCE, 0x13, 0x0A, 0xA1, 0x97, + 0xA8, 0x28, 0x6A, 0x8A, 0xFA, 0x9D, 0x55, 0xA6, 0x64, 0x23, 0x96, 0x1D, 0xB2, 0x2A, 0x51, 0x27, + 0xB6, 0x00, 0x83, 0x96, 0xF6, 0x05, 0x0F, 0x8F, 0xF4, 0x7D, 0x17, 0x20, 0x10, 0xB9, 0x7C, 0xA2, + 0x70, 0x81, 0x58, 0x15, 0x06, 0x49, 0xCA, 0xD1, 0x22, 0x21, 0xC4, 0x9E, 0x07, 0xD2, 0x1F, 0x34, + 0x57, 0x6F, 0xB5, 0xED, 0x81, 0x3D, 0x88, 0x5F, 0x8F, 0x9C, 0x0D, 0xEC, 0x65, 0xCC, 0x52, 0x7F, + 0x26, 0xCC, 0x3E, 0xB4, 0xEF, 0x7E, 0xD6, 0x6F, 0x18, 0xA8, 0xF7, 0xA0, 0xA8, 0x87, 0x78, 0x6A, + 0x4C, 0xFB, 0xEC, 0x5C, 0x4A, 0xE5, 0x2D, 0x99, 0xF2, 0x13, 0x0F, 0x6D, 0xA3, 0xD9, 0x0D, 0x40, + 0xFD, 0xF3, 0xC8, 0x5C, 0xE8, 0xCA, 0xF1, 0x10, 0xE7, 0x40, 0xAA, 0xE5, 0x26, 0x22, 0x6D, 0xF0, + 0xE9, 0x5B, 0xB0, 0x5F, 0x2F, 0x48, 0xD1, 0x74, 0x93, 0xC7, 0x62, 0x1E, 0x5D, 0xE8, 0x6B, 0xBA, + 0x3B, 0xC6, 0xB5, 0x0E, 0x7D, 0x5B, 0x0F, 0x1B, 0x4A, 0x9E, 0x28, 0xBC, 0x78, 0xDF, 0x8C, 0x61, + 0x3A, 0xCD, 0xB6, 0xEF, 0x9D, 0xAE, 0x35, 0x4F, 0xEB, 0x43, 0x9E, 0xCC, 0xA2, 0x1C, 0xAC, 0x40, + 0x94, 0xE8, 0x96, 0x97, 0x1C, 0x54, 0xBB, 0x59, 0x49, 0x01, 0x71, 0xA6, 0x95, 0xB2, 0x58, 0x2C, + 0xAD, 0x91, 0x01, 0x39, 0x53, 0x9B, 0xF4, 0x7F, 0xC3, 0x26, 0xFB, 0x95, 0x5D, 0x56, 0xB8, 0x98, + 0x30, 0x48, 0xC6, 0xE5, 0xC8, 0xBA, 0xE2, 0x88, 0x9C, 0x1F, 0x7B, 0x6F, 0xAD, 0x63, 0xB6, 0xAB, + 0x93, 0xB5, 0xEE, 0xBF, 0x42, 0xEC, 0x8F, 0xA6, 0x09, 0xC4, 0xB4, 0x6B, 0x5B, 0x16, 0x14, 0xCB, + 0xA4, 0xCC, 0x94, 0x62, 0xA7, 0x82, 0x6B, 0xED, 0xAC, 0x51, 0x23, 0x78, 0x8B, 0xF1, 0x48, 0xD6, + 0x12, 0x5F, 0xE7, 0x1D, 0x14, 0xD8, 0xF9, 0x42, 0xCA, 0xB9, 0x12, 0xFD, 0xDC, 0x29, 0xCB, 0x70, + 0xD8, 0x2B, 0x70, 0x75, 0xFC, 0x74, 0xAA, 0xA4, 0xEF, 0xFE, 0xD7, 0xF0, 0x29, 0xD5, 0xA8, 0xA7, + 0x9D, 0x9A, 0x88, 0x93, 0xE0, 0xFD, 0xC8, 0xD2, 0x4C, 0x81, 0x3D, 0x71, 0x25, 0x7A, 0x5C, 0xE8, + 0xC8, 0xBA, 0xBA, 0x15, 0x71, 0x1D, 0x77, 0x15, 0x3B, 0x34, 0x87, 0x61, 0xD1, 0xA5, 0xF4, 0x59, + 0x75, 0x18, 0x5D, 0x85, 0x4B, 0xE7, 0x15, 0x9B, 0xCE, 0xD0, 0x9C, 0x08, 0x90, 0x97, 0x55, 0x0B, + 0x06, 0x8E, 0xFA, 0x18, 0x99, 0xBC, 0xB1, 0x78, 0x80, 0xC7, 0x59, 0xEC, 0x43, 0x8C, 0x55, 0x32, + 0xCF, 0x2E, 0xDE, 0xC6, 0x23, 0xFA, 0xAE, 0xE5, 0xFC, 0x44, 0x78, 0x4A, 0xB9, 0xD2, 0xE5, 0xDC, + 0xE3, 0x47, 0x0D, 0xF2, 0x33, 0x77, 0xB3, 0xA7, 0x0A, 0x6B, 0xFC, 0xDA, 0xD3, 0x9B, 0x4A, 0x09, + 0x30, 0xC7, 0xE2, 0xB2, 0x9C, 0xE1, 0x46, 0xEA, 0xD7, 0xE5, 0x25, 0x1E, 0xA5, 0x08, 0xDD, 0x50, + 0xA3, 0x1F, 0x20, 0xCF, 0xF4, 0x85, 0x3F, 0xFD, 0x3C, 0xBC, 0xE5, 0xF3, 0x4A, 0xF9, 0xE8, 0x8C, + 0xF0, 0xAD, 0xCC, 0x27, 0x60, 0x29, 0xE2, 0xCD, 0x8C, 0xA0, 0x96, 0x0E, 0xD0, 0x2B, 0x9E, 0xB4, + 0x58, 0x11, 0x9C, 0x20, 0xC7, 0xB8, 0x3D, 0xB3, 0xA2, 0x85, 0x0F, 0x01, 0xBE, 0x19, 0x17, 0xC1, + 0x7E, 0x37, 0x75, 0xA1, 0xDB, 0x65, 0x85, 0x6F, 0xA0, 0x31, 0xE5, 0x11, 0x72, 0x1E, 0x91, 0x11, + 0x85, 0x88, 0xE1, 0x2F, 0xD6, 0xFC, 0xBA, 0x98, 0x13, 0x1E, 0xC5, 0xBF, 0xC1, 0xB6, 0xFA, 0xCC, + 0xBC, 0x73, 0x39, 0x2C, 0xC6, 0xFE, 0xF6, 0x4C, 0x70, 0xBC, 0xEA, 0x14, 0xEA, 0x61, 0x86, 0x93, + 0x38, 0x29, 0xFF, 0x1B, 0x83, 0x30, 0x0F, 0xEF, 0xE5, 0x58, 0xAF, 0x03, 0x72, 0x9F, 0xD3, 0x24, + 0xB3, 0x7E, 0x7F, 0x33, 0x76, 0x0E, 0x51, 0x5C, 0x41, 0x47, 0xBC, 0x30, 0x73, 0xF1, 0x64, 0xCA, + 0x87, 0x7F, 0xD0, 0xB7, 0x74, 0x03, 0x50, 0xA4, 0x0D, 0xBA, 0xB3, 0x24, 0x6F, 0x5E, 0x22, 0x89, + 0x6B, 0xD4, 0x07, 0xD3, 0x6B, 0x4D, 0x36, 0x5B, 0x8F, 0x85, 0xE6, 0xF3, 0x8A, 0x94, 0xDD, 0x60, + 0x70, 0x49, 0x14, 0x7F, 0x0A, 0xBC, 0x7B, 0xB2, 0xD0, 0x11, 0x87, 0x9E, 0xA2, 0x8D, 0xCF, 0x89, + 0x56, 0x34, 0x66, 0x71, 0x03, 0xB8, 0xF2, 0x93, 0xC3, 0x12, 0x10, 0x49, 0x29, 0x4B, 0x0A, 0xC8, + 0x88, 0x4C, 0x87, 0x0F, 0x84, 0x50, 0x74, 0x5B, 0x22, 0x78, 0xCF, 0xF7, 0xC8, 0xAB, 0x92, 0x4F, + 0x96, 0x54, 0x7B, 0xAB, 0xAE, 0xC2, 0x53, 0x8C, 0x5A, 0xF8, 0x0D, 0x8E, 0x8D, 0x25, 0x4A, 0xDA, + 0x94, 0xBE, 0x9A, 0x84, 0x56, 0x88, 0x08, 0x59, 0xA0, 0x44, 0x81, 0x48, 0x29, 0xF4, 0x38, 0x1B, + 0xD9, 0xBA, 0xB2, 0x1E, 0xA7, 0x9A, 0xA8, 0x06, 0x77, 0x76, 0x92, 0x7B, 0x25, 0x21, 0x4F, 0x41, + 0x3B, 0x2D, 0xE4, 0xD9, 0xC7, 0xE2, 0xE6, 0x43, 0x5A, 0x18, 0xA3, 0x92, 0xFE, 0xAB, 0x24, 0xC0, + 0x58, 0xC8, 0x02, 0xD8, 0xD1, 0x6C, 0xDD, 0xC9, 0x40, 0x1F, 0xD2, 0xF7, 0x90, 0xDB, 0x29, 0x22, + 0x26, 0x26, 0x83, 0xEA, 0xEB, 0xE2, 0x8A, 0x83, 0x56, 0x32, 0xDB, 0xE8, 0xF6, 0x06, 0x40, 0xE5, + 0x8B, 0xC4, 0xA8, 0xFC, 0x45, 0x2A, 0x22, 0xCF, 0xAB, 0xF6, 0x85, 0x73, 0x97, 0xC6, 0x91, 0xF1, + 0x2B, 0x31, 0xDC, 0x1C, 0xB2, 0x62, 0x9B, 0x6A, 0x02, 0xAC, 0x94, 0xDC, 0x5B, 0x39, 0xF0, 0xB6, + 0x57, 0xE8, 0x39, 0x9A, 0xA9, 0x87, 0x3F, 0x65, 0x5F, 0xD4, 0x49, 0x84, 0x91, 0x74, 0xEA, 0x7E, + 0xD2, 0x44, 0x74, 0x2A, 0xA7, 0x82, 0x28, 0x64, 0x85, 0x2E, 0x0D, 0xB1, 0x93, 0x51, 0x04, 0x0C, + 0x16, 0x3D, 0x42, 0xE2, 0x8F, 0xE9, 0x9F, 0x78, 0xD7, 0xD4, 0x18, 0xC2, 0x9F, 0x9C, 0x9A, 0x6B, + 0x03, 0x95, 0xF1, 0x23, 0xD1, 0x2B, 0x4C, 0x05, 0x1B, 0x8F, 0x21, 0x3B, 0x49, 0x91, 0xD6, 0xBB, + 0xE6, 0x7F, 0xF7, 0x41, 0x52, 0x67, 0x1E, 0x76, 0xDF, 0xF6, 0x8B, 0x7E, 0x84, 0xCD, 0x5A, 0x4F, + 0xB9, 0x7B, 0xEB, 0xBF, 0xFF, 0xC9, 0xC4, 0x69, 0x1D, 0x34, 0xDE, 0x2D, 0x33, 0xDE, 0x02, 0x4C, + 0x7F, 0x38, 0x7D, 0x84, 0xEF, 0x1E, 0x82, 0x6C, 0x28, 0x9E, 0x51, 0xB4, 0x94, 0x40, 0x1F, 0x93, + 0x20, 0x29, 0xE9, 0x6D, 0x61, 0x48, 0x19, 0x84, 0xC1, 0x70, 0xE5, 0xE1, 0x94, 0xAA, 0x43, 0x73, + 0xF6, 0x99, 0xC3, 0x1F, 0x5F, 0x52, 0xE6, 0x34, 0x70, 0x8C, 0x76, 0x26, 0xE7, 0xAA, 0x44, 0x26, + 0xB4, 0x00, 0x3F, 0x2D, 0xA0, 0x5B, 0xDE, 0xC6, 0x02, 0xE2, 0x5B, 0xF6, 0xDB, 0xB2, 0xA0, 0x76, + 0xFA, 0xA0, 0x95, 0x44, 0x11, 0xEE, 0x8D, 0x42, 0x16, 0x2E, 0x5E, 0xAC, 0xBB, 0xC5, 0x65, 0xE8, + 0x49, 0x29, 0xC1, 0x3B, 0x6A, 0x8D, 0x27, 0xEB, 0x25, 0x3B, 0x41, 0x19, 0x4A, 0xB3, 0x0A, 0x95, + 0x20, 0xEB, 0xA6, 0x0B, 0x20, 0xC3, 0xE1, 0xFC, 0x2A, 0x5C, 0xD6, 0xA2, 0x31, 0x70, 0xB0, 0xE6, + 0xEA, 0xC9, 0x11, 0xAB, 0xD2, 0x41, 0xF2, 0xB4, 0x13, 0xDC, 0x79, 0xAB, 0xA0, 0xF3, 0x3C, 0x13, + 0xC9, 0xE3, 0x19, 0xC0, 0x1F, 0x7A, 0x48, 0xEB, 0x06, 0x62, 0x4D, 0xEC, 0x67, 0x14, 0x60, 0x83, + 0xD6, 0xA8, 0xBF, 0xDF, 0x08, 0x21, 0xDF, 0x04, 0x94, 0x26, 0xC9, 0xDA, 0xD0, 0xA3, 0x04, 0xDC, + 0x03, 0x14, 0x90, 0x17, 0xB8, 0x5A, 0x4B, 0xF6, 0x75, 0x9B, 0xAB, 0xB3, 0xA5, 0xC3, 0xC9, 0xFE, + 0x75, 0xE1, 0x47, 0x59, 0xB5, 0xD4, 0x17, 0x94, 0xD5, 0xF4, 0x2A, 0x52, 0x7D, 0xCC, 0xC6, 0x4F, + 0x99, 0x14, 0x65, 0xDE, 0x5C, 0xD7, 0x32, 0xAB, 0x75, 0xA9, 0x6E, 0x82, 0xE3, 0xE7, 0xF4, 0xF3, + 0xC1, 0x4A, 0xE3, 0x19, 0x4F, 0xD2, 0xA7, 0xFE, 0xE5, 0x42, 0x6E, 0x38, 0xF4, 0x33, 0x6E, 0xF9, + 0x0C, 0x76, 0xF1, 0x89, 0x55, 0xAB, 0x08, 0x3D, 0xC5, 0x47, 0x4E, 0xB5, 0x2F, 0x00, 0x33, 0x84, + 0xCD, 0xCE, 0x24, 0xEA, 0xDB, 0x3D, 0x25, 0x9B, 0x24, 0xC1, 0xCA, 0xA3, 0xB6, 0x3A, 0x7D, 0xBF, + 0x8A, 0xB9, 0x60, 0xEF, 0xE6, 0x2B, 0x8C, 0x4A, 0xAC, 0x3F, 0xA4, 0x0D, 0x82, 0x8E, 0xD1, 0x70, + 0x67, 0x97, 0xA7, 0x17, 0xB9, 0x52, 0xB2, 0x5A, 0xE8, 0xEC, 0x8D, 0x94, 0xC5, 0x96, 0xFC, 0x9B, + 0xD3, 0x10, 0x7E, 0xD3, 0x06, 0xB4, 0xAA, 0xC7, 0x63, 0xA1, 0x56, 0x9F, 0x04, 0x7F, 0x96, 0xEE, + 0x39, 0xDC, 0x18, 0x60, 0x2F, 0x71, 0x2D, 0xEB, 0xF5, 0x1A, 0x4D, 0xFE, 0xB3, 0x49, 0x37, 0xFE, + 0xC5, 0x7F, 0x6C, 0xEE, 0x17, 0x48, 0xF5, 0xED, 0xA7, 0xB9, 0x95, 0x0B, 0x61, 0x2E, 0x2C, 0x87, + 0xA7, 0x5D, 0xA5, 0xAC, 0x89, 0xEC, 0x11, 0x0C, 0xD5, 0xCD, 0xE1, 0xB6, 0x9C, 0x4B, 0x8F, 0xCF, + 0x21, 0x75, 0xA1, 0x1B, 0x35, 0x41, 0x4D, 0x4E, 0x9B, 0xDE, 0xE2, 0xE8, 0x0E, 0x23, 0x9A, 0x9A, + 0x2B, 0xAC, 0x41, 0x6E, 0xEF, 0xD1, 0xAC, 0x7E, 0x74, 0xB7, 0x16, 0x83, 0x10, 0x85, 0x84, 0x60, + 0x28, 0xF0, 0xD1, 0xA0, 0x5E, 0xB7, 0x8E, 0xEF, 0x7B, 0x4C, 0x27, 0xAF, 0x8A, 0x9E, 0x3F, 0x29, + 0x1B, 0x12, 0x01, 0x07, 0xF1, 0xAA, 0xFE, 0x2E, 0xFF, 0x18, 0x9A, 0xCD, 0xF4, 0x0E, 0xC1, 0x74, + 0x6D, 0xD4, 0xCE, 0xF3, 0xF9, 0x3C, 0xE2, 0x12, 0x03, 0x07, 0x1B, 0x9D, 0x3D, 0x6E, 0xD9, 0x79, + 0xB3, 0x56, 0x14, 0xC5, 0xEA, 0x06, 0xD1, 0xAD, 0x2C, 0x07, 0x58, 0x90, 0x0E, 0x80, 0x6B, 0x60, + 0x43, 0x82, 0xAA, 0x0C, 0xEE, 0x1B +}; + +uint8 Module_0DBBF209A27B1E279A9FEC5C168A15F7_Key[16] = +{ + 0x5B, 0x27, 0x27, 0x01, 0x24, 0x56, 0xB4, 0xD4, 0x2D, 0xD0, 0x96, 0x77, 0x49, 0x51, 0xDC, 0x0A +}; + +#endif diff --git a/src/server/game/Warden/Modules/WardenModuleWin.h b/src/server/game/Warden/Modules/WardenModuleWin.h new file mode 100644 index 000000000..ca61a270a --- /dev/null +++ b/src/server/game/Warden/Modules/WardenModuleWin.h @@ -0,0 +1,1204 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDEN_MODULE_WIN_H +#define _WARDEN_MODULE_WIN_H + +uint8 Module_79C0768D657977D697E10BAD956CCED1_Data[18756] = +{ + 0x21, 0x6C, 0xBB, 0x6A, 0xB9, 0xAF, 0xE8, 0xA1, 0x9A, 0x79, 0x18, 0xF1, 0x27, 0x9A, 0x14, 0xF5, + 0x42, 0x5D, 0x00, 0xBA, 0x74, 0x57, 0x0E, 0xAF, 0xD2, 0xAE, 0x8E, 0x51, 0xA5, 0xC1, 0x17, 0x4E, + 0xEC, 0x7F, 0xAC, 0xBC, 0xDD, 0x42, 0x87, 0xA6, 0xF9, 0xC1, 0x4A, 0xCE, 0xB5, 0xDD, 0xB3, 0xF8, + 0x06, 0x52, 0x9D, 0xF2, 0xAE, 0x2A, 0x49, 0x2B, 0x7B, 0x72, 0x5F, 0x40, 0x01, 0x16, 0xDB, 0x98, + 0x77, 0x1F, 0xE3, 0x61, 0x5A, 0x99, 0x39, 0x66, 0x2F, 0x2F, 0x35, 0xBF, 0x00, 0x20, 0xE4, 0xE0, + 0x8F, 0x98, 0xAD, 0xFC, 0xDB, 0x7D, 0xDD, 0xE8, 0x7A, 0xE9, 0x21, 0x6C, 0x86, 0x80, 0x3A, 0xE7, + 0x75, 0x66, 0x0E, 0xD9, 0xC6, 0xC5, 0xD8, 0xD8, 0xA9, 0x9B, 0x84, 0x09, 0xF0, 0xB3, 0x7C, 0x72, + 0x53, 0xE2, 0x29, 0xF9, 0x64, 0x8C, 0x17, 0xFD, 0x90, 0xAE, 0x48, 0x5A, 0x30, 0xFA, 0x30, 0xB7, + 0x54, 0x58, 0x59, 0x61, 0xA0, 0x24, 0x57, 0xE4, 0xF0, 0x05, 0xA2, 0x3F, 0x7A, 0xA6, 0x51, 0x7E, + 0x4F, 0x35, 0xF4, 0xE5, 0xFF, 0x98, 0xE9, 0x3E, 0x1F, 0xF1, 0x66, 0x48, 0x5B, 0xF8, 0xCF, 0x3B, + 0x37, 0x3B, 0x60, 0x47, 0x1C, 0xF7, 0xBE, 0x59, 0x70, 0x3A, 0x03, 0x4C, 0xE6, 0xBD, 0xB6, 0xED, + 0x46, 0xAF, 0x04, 0x5A, 0xAA, 0xC4, 0x30, 0xCF, 0x0B, 0x05, 0x86, 0xA9, 0x56, 0x5B, 0x09, 0xF0, + 0x92, 0x59, 0xC8, 0x48, 0x58, 0x33, 0xBF, 0x81, 0x70, 0x51, 0x92, 0x98, 0xE9, 0x4F, 0x2B, 0xDD, + 0x5B, 0x0A, 0x42, 0x51, 0x73, 0x97, 0xF6, 0x66, 0x00, 0xF2, 0x04, 0x50, 0x4A, 0x54, 0x62, 0x7A, + 0x00, 0x10, 0x5B, 0xAD, 0x0E, 0xFC, 0xE1, 0x44, 0x55, 0x4E, 0x21, 0x76, 0xC6, 0x4B, 0xD5, 0x2E, + 0xF5, 0xF4, 0x0E, 0xFC, 0x55, 0xE1, 0xDE, 0x32, 0x20, 0x22, 0x03, 0x98, 0xF0, 0xD3, 0x4A, 0xE5, + 0x45, 0x49, 0x0C, 0xE8, 0x76, 0xE1, 0xBF, 0x4A, 0x53, 0xD3, 0xCE, 0x64, 0xCF, 0x82, 0xCF, 0x67, + 0xA9, 0x3F, 0xF1, 0x06, 0x24, 0x33, 0x0A, 0x98, 0x6A, 0x5C, 0xAB, 0xEE, 0x7F, 0x64, 0xE3, 0x65, + 0x1F, 0xF6, 0xBE, 0xAF, 0x9C, 0x63, 0x53, 0x54, 0x06, 0x84, 0x4F, 0xF2, 0x7D, 0xC5, 0xBD, 0x70, + 0xC7, 0x6F, 0x59, 0x93, 0x7C, 0xEE, 0xC0, 0xCA, 0xF5, 0x56, 0x21, 0x58, 0x5B, 0xD8, 0x1D, 0xB4, + 0xB7, 0x60, 0x72, 0x46, 0xA2, 0x60, 0x3F, 0xC3, 0x30, 0xAB, 0xE0, 0x3B, 0xAC, 0x9E, 0xB9, 0x64, + 0xA8, 0xEF, 0xD0, 0xE1, 0xE5, 0xE1, 0x83, 0x48, 0xB8, 0x35, 0xA7, 0x12, 0x11, 0x00, 0xC9, 0x29, + 0x1A, 0x41, 0x1D, 0x3B, 0xFB, 0x33, 0x0B, 0x66, 0x45, 0x86, 0x61, 0x70, 0x35, 0x4C, 0x5F, 0x64, + 0x8E, 0xF5, 0x57, 0xBE, 0xA6, 0xFA, 0x49, 0xC9, 0x89, 0xA4, 0x74, 0x02, 0x9E, 0xE7, 0x67, 0x14, + 0x8B, 0xB9, 0xE7, 0xA8, 0xB0, 0x75, 0x65, 0x22, 0xB7, 0xCD, 0xFA, 0x55, 0x18, 0x00, 0x55, 0xB5, + 0x09, 0x70, 0x7E, 0x05, 0x0B, 0x11, 0x42, 0xF0, 0x80, 0x58, 0x2F, 0xFE, 0x3B, 0x2C, 0x4A, 0xCA, + 0x50, 0x34, 0xD0, 0x6F, 0xF1, 0xCC, 0x7F, 0x35, 0xD7, 0x9B, 0xF2, 0x97, 0x16, 0xFE, 0x5F, 0x6C, + 0x94, 0xDC, 0xAC, 0x63, 0xC8, 0x85, 0x2E, 0x60, 0x41, 0x34, 0x89, 0xD3, 0xDD, 0xBF, 0x2D, 0x69, + 0xC2, 0xF7, 0x74, 0xB2, 0x56, 0xD9, 0x76, 0xA2, 0x35, 0x30, 0x60, 0x35, 0xAB, 0x50, 0x21, 0xAE, + 0xFC, 0xFA, 0x19, 0x06, 0xDE, 0x89, 0x46, 0xFF, 0x34, 0x2F, 0x19, 0x84, 0x85, 0xF5, 0x1E, 0x60, + 0x91, 0x0D, 0x8C, 0x94, 0xDB, 0x2E, 0xEE, 0x4D, 0x0A, 0x29, 0x64, 0x81, 0xAD, 0x4C, 0xBF, 0x41, + 0x51, 0x04, 0xCD, 0x1C, 0x5C, 0x89, 0xD3, 0x3A, 0x91, 0xD9, 0x5C, 0x7E, 0xF3, 0xE9, 0x5B, 0x9E, + 0xC2, 0xD2, 0xE4, 0xD5, 0xEF, 0x47, 0x63, 0xD2, 0xD4, 0x19, 0x3E, 0xDF, 0xCF, 0xA4, 0x10, 0x47, + 0x16, 0x93, 0xC2, 0xF2, 0x22, 0xED, 0x1D, 0x9E, 0x21, 0x63, 0xC4, 0xCB, 0x89, 0xBB, 0x3E, 0xF7, + 0x89, 0x68, 0x6D, 0x2C, 0xDF, 0x2C, 0x6F, 0xB2, 0x8D, 0x75, 0xF8, 0xC6, 0x57, 0x98, 0x47, 0x86, + 0x40, 0x72, 0xBB, 0xD7, 0x32, 0xCD, 0x7A, 0x15, 0x64, 0x83, 0xD9, 0x50, 0x2E, 0xDE, 0x0C, 0x8C, + 0x30, 0xCD, 0xB0, 0x64, 0xD6, 0x7F, 0xE7, 0xAD, 0x6E, 0x01, 0x3E, 0x14, 0x8A, 0x24, 0x86, 0x1F, + 0x92, 0xAB, 0x1A, 0xE5, 0xD6, 0xBF, 0x64, 0xE5, 0xF6, 0x34, 0x62, 0xD5, 0x92, 0x5B, 0x64, 0xC4, + 0xFC, 0x1B, 0x7F, 0xA0, 0x13, 0xC1, 0xD4, 0xEB, 0x92, 0x90, 0xEF, 0x8C, 0x5E, 0x75, 0x4B, 0x78, + 0x56, 0x5F, 0xA2, 0x55, 0x4B, 0x1B, 0xE3, 0xDD, 0x80, 0x7E, 0xCF, 0x69, 0x97, 0x5A, 0x76, 0xD5, + 0xAA, 0x7D, 0x85, 0x73, 0x10, 0x4E, 0x79, 0x9A, 0x10, 0x10, 0x01, 0xD8, 0xD7, 0x85, 0x41, 0x8D, + 0x3D, 0xEA, 0xE3, 0x59, 0xD9, 0x31, 0x4B, 0x23, 0xC6, 0x53, 0x11, 0xA6, 0x35, 0x29, 0x64, 0x7E, + 0x28, 0xD7, 0x8D, 0x03, 0x70, 0x5C, 0x53, 0xA7, 0x6D, 0x81, 0x30, 0x7B, 0xDF, 0x2B, 0xAE, 0xAB, + 0x6F, 0x52, 0x93, 0xCF, 0xDD, 0x00, 0x35, 0xE9, 0x65, 0x4A, 0x04, 0x79, 0x11, 0x30, 0xCA, 0xC7, + 0xD2, 0xF3, 0x34, 0xAC, 0x32, 0x1F, 0xE4, 0xE5, 0x83, 0x12, 0x66, 0xD6, 0xA6, 0xE4, 0xEB, 0x67, + 0x7E, 0xDD, 0x64, 0x3E, 0xF1, 0x0C, 0xE6, 0x1C, 0xB6, 0xE1, 0xB0, 0x2B, 0xE7, 0x83, 0xB4, 0x4A, + 0x82, 0xDD, 0xC1, 0x22, 0x3F, 0x03, 0x38, 0x90, 0xB2, 0xA9, 0x7B, 0x60, 0x57, 0xF9, 0xDD, 0x04, + 0x60, 0x5D, 0x7C, 0x2C, 0xD3, 0xE6, 0xFE, 0x02, 0x5A, 0x7D, 0x2A, 0x48, 0x81, 0x42, 0x20, 0x84, + 0xFF, 0x1D, 0xCC, 0x64, 0x11, 0x70, 0xE5, 0x4F, 0x9F, 0xE0, 0x11, 0xFB, 0xF0, 0xE2, 0xC4, 0x9B, + 0x11, 0x30, 0x7F, 0x2F, 0x7F, 0xA1, 0xB1, 0xBC, 0x5F, 0x29, 0x21, 0xDF, 0xB4, 0xEB, 0xB2, 0x4F, + 0xAA, 0x2D, 0x95, 0x60, 0x47, 0x78, 0x37, 0x67, 0xCD, 0xFA, 0x36, 0x17, 0x8F, 0x64, 0x15, 0xAF, + 0x04, 0xAA, 0x5C, 0x76, 0x23, 0x07, 0x64, 0x96, 0xB2, 0x5A, 0xCF, 0x03, 0xDC, 0xC3, 0x2D, 0xFB, + 0x0D, 0x2D, 0xA8, 0xBD, 0xCE, 0x58, 0xF8, 0x44, 0x75, 0xA1, 0x07, 0xAA, 0xDF, 0x25, 0xDC, 0x25, + 0x32, 0xCF, 0xA8, 0x92, 0xC5, 0xC0, 0xD5, 0x70, 0x21, 0x19, 0x6F, 0x32, 0xCA, 0x16, 0xFA, 0x8C, + 0xB2, 0x86, 0xF6, 0xD5, 0x2E, 0xD9, 0x0A, 0x9C, 0x96, 0xDB, 0x4D, 0xA4, 0x11, 0x02, 0x4C, 0x33, + 0x99, 0xB3, 0x5E, 0x45, 0x5C, 0xF1, 0x99, 0x61, 0x04, 0x20, 0xC9, 0xC8, 0xB3, 0xB4, 0xD3, 0x8B, + 0x24, 0x78, 0x55, 0x2E, 0xB7, 0x48, 0x43, 0x17, 0xBF, 0xB9, 0x2A, 0xCC, 0xD5, 0x4A, 0x49, 0xB2, + 0x4E, 0x1E, 0xC7, 0x45, 0x4E, 0x55, 0xC4, 0xBC, 0xB1, 0xD2, 0xA6, 0x62, 0xE9, 0x95, 0xBB, 0xCD, + 0x87, 0xD2, 0x7C, 0xE5, 0xC6, 0x77, 0x5B, 0xFF, 0xAF, 0xDD, 0x44, 0x9D, 0x3D, 0x10, 0x05, 0x3C, + 0x77, 0x7A, 0xF8, 0x84, 0x0D, 0x04, 0x55, 0xB5, 0x20, 0xEA, 0xD2, 0x3F, 0x04, 0x33, 0xFF, 0xE2, + 0x01, 0x3B, 0x51, 0x46, 0x3E, 0x34, 0xAA, 0x40, 0xCA, 0x7C, 0x85, 0x46, 0x57, 0xD9, 0xB7, 0xE1, + 0xDC, 0x65, 0xEF, 0x11, 0x66, 0x0B, 0xBA, 0xD8, 0x37, 0x66, 0x96, 0x64, 0x54, 0x8B, 0x05, 0x81, + 0x47, 0x87, 0x70, 0xA8, 0x54, 0xC6, 0x02, 0x08, 0xB4, 0xAD, 0x69, 0x3C, 0xC0, 0x03, 0x69, 0x19, + 0xE6, 0xAC, 0x13, 0xD5, 0x3F, 0x2C, 0x9D, 0x61, 0xCC, 0xA8, 0x60, 0xB5, 0x60, 0x85, 0x19, 0x5B, + 0x3E, 0x82, 0xCA, 0x34, 0x70, 0x06, 0xCD, 0x37, 0x3E, 0x91, 0x2F, 0x49, 0x82, 0x0A, 0x87, 0xE8, + 0x09, 0x18, 0xB3, 0xF4, 0x16, 0xA4, 0xA5, 0x46, 0xC5, 0x76, 0x6D, 0x73, 0xB1, 0x93, 0xDC, 0x69, + 0xF4, 0x49, 0xF8, 0x2F, 0x97, 0xB4, 0xAA, 0x19, 0x4A, 0x60, 0xD2, 0xF9, 0x7B, 0x5A, 0xF0, 0x57, + 0x45, 0xC6, 0xA2, 0x64, 0x37, 0x56, 0xED, 0x6B, 0x5E, 0x1D, 0x9E, 0x35, 0x5E, 0xFE, 0xDE, 0x04, + 0x08, 0x3B, 0x62, 0x40, 0x82, 0xD4, 0xF9, 0xF3, 0x54, 0x95, 0x3E, 0x57, 0x49, 0x3A, 0x41, 0x41, + 0xDA, 0xD4, 0x78, 0x80, 0xC7, 0xF1, 0xDE, 0xA7, 0xFF, 0xDC, 0x53, 0xC9, 0x3A, 0x37, 0xA5, 0x83, + 0xDE, 0xE8, 0x51, 0x33, 0x7B, 0xE6, 0xAC, 0xA5, 0xC4, 0x7D, 0x34, 0xB0, 0x99, 0x0D, 0x03, 0x34, + 0x0F, 0x8D, 0xB8, 0x10, 0x4E, 0x30, 0x38, 0x10, 0xFC, 0x62, 0xC3, 0xC0, 0xF5, 0x67, 0x69, 0xF5, + 0x23, 0xB4, 0xF2, 0x6B, 0x79, 0xA8, 0xEE, 0xF0, 0xDD, 0x06, 0xA1, 0x50, 0x41, 0x3E, 0x1D, 0x04, + 0xB0, 0xB7, 0xC8, 0x58, 0x20, 0x72, 0xF6, 0x41, 0x53, 0x58, 0xAA, 0xAB, 0xA1, 0x19, 0xB0, 0x99, + 0xE4, 0x35, 0x44, 0x32, 0xF0, 0x34, 0x52, 0x4E, 0xD0, 0xBC, 0x1D, 0xD2, 0x14, 0x6A, 0x22, 0x46, + 0x93, 0x52, 0xFF, 0xD5, 0xD9, 0xEF, 0x19, 0xAF, 0xFB, 0x9A, 0x0D, 0x4A, 0x14, 0x49, 0xAE, 0xC0, + 0x09, 0x5E, 0x40, 0x36, 0x63, 0xE7, 0xC3, 0xFA, 0x84, 0x1C, 0xBF, 0x65, 0x17, 0xED, 0xED, 0x49, + 0x93, 0xB9, 0xCD, 0x85, 0x3F, 0x95, 0x57, 0xF9, 0xE7, 0x59, 0x55, 0x59, 0xED, 0x3A, 0xA1, 0x90, + 0x24, 0x36, 0xB8, 0x38, 0x91, 0x57, 0x59, 0xDB, 0xDE, 0x8E, 0x8B, 0x3A, 0xBB, 0x31, 0x76, 0x39, + 0x0D, 0x20, 0x84, 0x8A, 0x05, 0x5A, 0xC1, 0x93, 0x04, 0x5E, 0x9E, 0x2E, 0x41, 0x13, 0xC9, 0x7F, + 0xAB, 0x45, 0x86, 0x99, 0xB2, 0x5C, 0x7E, 0x1A, 0x1C, 0x9C, 0x7C, 0xCF, 0x60, 0x38, 0xF7, 0x02, + 0x8A, 0xE6, 0x74, 0x4F, 0x31, 0x67, 0x99, 0x96, 0xC3, 0x79, 0xEB, 0x19, 0x07, 0xAD, 0xBB, 0xD2, + 0xD7, 0x51, 0x75, 0xDD, 0xD5, 0x44, 0xC2, 0x9A, 0xDE, 0x01, 0x68, 0x8C, 0xBF, 0x11, 0xFE, 0x5F, + 0xB9, 0xCF, 0x25, 0x35, 0xD2, 0xF7, 0x29, 0xE0, 0x63, 0x0F, 0x0A, 0xCA, 0xB9, 0x38, 0xB6, 0xDA, + 0xDD, 0x66, 0xD9, 0x5F, 0x67, 0x42, 0x15, 0xD8, 0x1C, 0xD1, 0x1C, 0xCC, 0xD6, 0xB9, 0x29, 0x85, + 0x99, 0xD6, 0xDD, 0xCE, 0x8E, 0x3D, 0x63, 0x1C, 0x31, 0x32, 0x37, 0xCD, 0xE1, 0xF8, 0xEA, 0x4E, + 0x31, 0x25, 0xF7, 0x2D, 0xE1, 0xCA, 0x36, 0x5B, 0xEC, 0xAC, 0x2B, 0xB0, 0xA5, 0x69, 0x3B, 0x4C, + 0xAE, 0xD7, 0x15, 0xF7, 0x7F, 0x5C, 0x5F, 0x82, 0xF0, 0x1D, 0x44, 0x62, 0xA0, 0x72, 0x57, 0xAD, + 0xB3, 0xD7, 0x1B, 0xA9, 0xE2, 0x76, 0xFF, 0x18, 0xA6, 0x3E, 0xF9, 0xF5, 0x6F, 0xB5, 0x13, 0x26, + 0x72, 0x0F, 0xF4, 0xE1, 0x7D, 0x43, 0x86, 0x48, 0x42, 0x0B, 0x94, 0x96, 0xBF, 0x0E, 0x32, 0x1C, + 0xE0, 0x18, 0x69, 0xA9, 0xAE, 0x83, 0x6F, 0x36, 0xE7, 0x04, 0x20, 0xEE, 0x34, 0xFF, 0x21, 0xE9, + 0xBA, 0x3B, 0x38, 0x48, 0x2D, 0x81, 0x38, 0x48, 0x25, 0xE5, 0x4A, 0xAD, 0x81, 0xA9, 0xE8, 0x33, + 0x0A, 0x4C, 0x60, 0xAE, 0xBB, 0xCC, 0x24, 0x96, 0x44, 0xF3, 0x1A, 0x2A, 0x89, 0xCB, 0xD9, 0x5E, + 0x89, 0x4C, 0xFD, 0x62, 0xA8, 0x38, 0x1E, 0x73, 0x63, 0xB3, 0xF1, 0x3E, 0xAC, 0xB1, 0x0B, 0x5D, + 0x10, 0xE5, 0xCC, 0x88, 0x2F, 0x9D, 0x57, 0xF1, 0x33, 0xA6, 0x50, 0x13, 0x2C, 0x54, 0x81, 0x1B, + 0x90, 0xD8, 0x6F, 0x7C, 0x02, 0x86, 0xA8, 0x02, 0x5F, 0xCE, 0x24, 0x22, 0x76, 0x73, 0xE8, 0x66, + 0xDC, 0x7F, 0x8F, 0x69, 0x4E, 0xBB, 0x63, 0xEB, 0xCD, 0x38, 0xE6, 0xEE, 0x84, 0x70, 0x97, 0x2F, + 0xD1, 0x77, 0xEE, 0x63, 0xE4, 0x2D, 0x42, 0xDE, 0x17, 0x95, 0x18, 0xB5, 0xA9, 0x4D, 0xFD, 0x2A, + 0xA8, 0x07, 0x1F, 0xCC, 0x3F, 0x22, 0x3B, 0x03, 0x49, 0xCF, 0x83, 0x83, 0x85, 0xAA, 0x87, 0xA0, + 0xC6, 0x30, 0x8C, 0x8F, 0x91, 0x88, 0x67, 0xA7, 0x1F, 0xE0, 0xE2, 0x40, 0x1E, 0xE9, 0x12, 0x2E, + 0x5C, 0x33, 0x44, 0x29, 0x0D, 0xEA, 0x34, 0x8B, 0x1A, 0x48, 0x80, 0x67, 0x45, 0x2A, 0xF2, 0x82, + 0xD8, 0x78, 0x7E, 0x36, 0x59, 0x6C, 0x32, 0x58, 0x3B, 0x0F, 0x2C, 0x0B, 0xD1, 0xFA, 0x67, 0x2B, + 0x0C, 0xFF, 0x16, 0x57, 0x04, 0x38, 0x51, 0x4F, 0x34, 0xEE, 0x94, 0x8B, 0xBB, 0x7B, 0xBE, 0xEA, + 0x37, 0xB5, 0x9F, 0xBA, 0xDE, 0xC1, 0xC6, 0x34, 0x2D, 0x36, 0xE6, 0xC8, 0x67, 0x6A, 0x74, 0x56, + 0xB5, 0x05, 0x53, 0xAE, 0x5C, 0x94, 0x83, 0xF9, 0xE0, 0xD7, 0x21, 0xC2, 0x71, 0x4B, 0x0F, 0x9C, + 0x64, 0x1C, 0xF4, 0x6A, 0xF8, 0xE3, 0x3C, 0x8F, 0xD2, 0x20, 0xCF, 0x14, 0xAC, 0x21, 0xF5, 0x2A, + 0xE7, 0xEC, 0x5C, 0x49, 0xAB, 0x21, 0xF2, 0x41, 0x2C, 0x3B, 0xA0, 0x49, 0x43, 0xF3, 0x14, 0xFE, + 0x68, 0x7C, 0x83, 0x05, 0xF3, 0x71, 0x77, 0x02, 0x2B, 0xD4, 0x94, 0x2B, 0x28, 0x5E, 0x4A, 0x5E, + 0x6E, 0x81, 0x1A, 0xD3, 0xDA, 0x58, 0x9F, 0xD6, 0x7B, 0x6D, 0xAD, 0x14, 0xBC, 0x60, 0xFC, 0xC4, + 0x83, 0x0A, 0x8E, 0x9B, 0x8D, 0x5B, 0x24, 0x77, 0x10, 0x34, 0x78, 0xC9, 0x8F, 0xA5, 0x2D, 0x0F, + 0x6A, 0x88, 0x7F, 0x24, 0x40, 0x46, 0x25, 0x3A, 0xDE, 0xB9, 0x9E, 0xA2, 0xE7, 0x8D, 0x52, 0xA2, + 0xFF, 0xDE, 0xB4, 0x95, 0xDB, 0x05, 0x2E, 0xDF, 0x29, 0x28, 0xB5, 0x76, 0xD6, 0x1D, 0x09, 0x45, + 0x69, 0x29, 0xF9, 0x95, 0xAA, 0x36, 0x71, 0xD9, 0x3F, 0xFF, 0x6B, 0x04, 0xFE, 0xED, 0x63, 0xC8, + 0x3C, 0x4B, 0x6B, 0x0B, 0xF3, 0xD8, 0x71, 0x15, 0xDA, 0xC0, 0xC9, 0xE2, 0x0D, 0x87, 0x94, 0x61, + 0xBE, 0xEF, 0x79, 0x92, 0x4C, 0x14, 0x92, 0xBF, 0x0C, 0x4E, 0xA0, 0x1B, 0x58, 0x00, 0x30, 0xF6, + 0xD0, 0x09, 0xD6, 0x1E, 0x81, 0xA0, 0xE7, 0xFD, 0xFD, 0xFF, 0x21, 0x47, 0xAB, 0xDE, 0x67, 0xC6, + 0xF4, 0x19, 0x60, 0x0C, 0x49, 0xE5, 0xC4, 0xBD, 0x64, 0x05, 0xED, 0x89, 0xD7, 0xBD, 0x74, 0xF7, + 0xD4, 0xCC, 0x4B, 0x9E, 0xEB, 0x6E, 0xB7, 0x87, 0xB6, 0x31, 0x07, 0xCB, 0x6E, 0x0D, 0xDF, 0x3A, + 0xD8, 0x64, 0x1F, 0xF9, 0x2C, 0xEE, 0xC0, 0x61, 0x22, 0x0E, 0x5A, 0x20, 0x0C, 0xD4, 0x4F, 0xC5, + 0x2D, 0x82, 0x63, 0x39, 0x36, 0x34, 0x07, 0xC6, 0x23, 0xBC, 0xF1, 0x56, 0xC6, 0x8C, 0x39, 0x23, + 0x43, 0xFF, 0xEC, 0xBE, 0x95, 0x7B, 0xC7, 0xFD, 0xA9, 0x99, 0x3D, 0xDF, 0x50, 0x28, 0x39, 0xCA, + 0x80, 0xCF, 0x1C, 0xE7, 0x81, 0x06, 0xB4, 0x43, 0x55, 0xFB, 0xB0, 0xA4, 0x5D, 0x78, 0x39, 0x71, + 0x88, 0xEC, 0xBB, 0x01, 0x69, 0x5E, 0x85, 0x97, 0x1F, 0xEB, 0x6C, 0x82, 0x07, 0xF4, 0x00, 0x1B, + 0x90, 0x03, 0x1B, 0x92, 0x9A, 0x4A, 0x95, 0x9D, 0x45, 0x45, 0x65, 0x6F, 0x8B, 0x70, 0x4C, 0xFE, + 0x48, 0x94, 0x5B, 0x71, 0x86, 0x70, 0x45, 0xB7, 0x85, 0xD9, 0x59, 0x29, 0x94, 0x47, 0x5A, 0x17, + 0x96, 0xA1, 0x0E, 0xFD, 0x72, 0x71, 0xE1, 0x3F, 0x7B, 0xE6, 0x59, 0x2A, 0x91, 0x5A, 0x6B, 0x82, + 0xB1, 0xA1, 0x31, 0xC2, 0xE4, 0xE3, 0xB9, 0x8E, 0x5A, 0x68, 0xC1, 0x18, 0xD4, 0x4B, 0x02, 0x2E, + 0x50, 0x3D, 0x73, 0x53, 0x2B, 0x13, 0x77, 0x19, 0xC7, 0x03, 0x0B, 0xB5, 0xAD, 0x5C, 0x0B, 0x6B, + 0x66, 0x12, 0xF0, 0xE8, 0x67, 0xB7, 0xF7, 0x88, 0x64, 0xA8, 0x2C, 0x51, 0xA7, 0xF8, 0x5E, 0xB3, + 0x39, 0xEC, 0x1B, 0xDF, 0x6C, 0x89, 0x16, 0xFD, 0x51, 0x26, 0x29, 0x8D, 0x0E, 0xBE, 0x1B, 0xCE, + 0x61, 0xE5, 0x22, 0x09, 0xC1, 0x0F, 0xAD, 0x0C, 0xA1, 0x61, 0xF8, 0x49, 0x29, 0x11, 0x7C, 0x93, + 0x0C, 0xBE, 0xD0, 0x11, 0x6F, 0x24, 0x4E, 0x4B, 0xF5, 0xEF, 0x41, 0x3D, 0x0C, 0x69, 0xC6, 0xA6, + 0xBF, 0x87, 0x68, 0xFF, 0x2F, 0x76, 0xD9, 0xFD, 0x1D, 0x8E, 0x9F, 0x80, 0x19, 0x3B, 0x35, 0x8B, + 0x2D, 0xDB, 0x5C, 0x3E, 0x86, 0xE8, 0xBF, 0xF1, 0x30, 0x88, 0xE4, 0x80, 0xD0, 0x49, 0xC3, 0x50, + 0xF8, 0x1E, 0xCE, 0xDA, 0xAC, 0x2E, 0x3F, 0x97, 0x51, 0x12, 0x89, 0x47, 0x5D, 0xF4, 0xD4, 0x77, + 0x93, 0x66, 0x74, 0xE3, 0x4C, 0xCD, 0xB4, 0xC8, 0x00, 0x85, 0x64, 0x8C, 0x04, 0x72, 0x1C, 0x14, + 0xDA, 0x77, 0xD7, 0x1D, 0x39, 0xC3, 0x65, 0xD0, 0x28, 0x51, 0xCA, 0x91, 0xAE, 0x2D, 0xCD, 0x50, + 0x0D, 0x1B, 0xA4, 0xF1, 0x5D, 0x4C, 0x28, 0x1C, 0x57, 0xE5, 0x00, 0xEC, 0xA4, 0x02, 0x3B, 0xCA, + 0x70, 0xF3, 0x8B, 0x3C, 0x4F, 0xEE, 0x9D, 0x08, 0xFF, 0x66, 0x31, 0xCE, 0x37, 0x93, 0x90, 0x3D, + 0x6E, 0xDE, 0xB9, 0xCF, 0x35, 0xAA, 0xF0, 0x43, 0x3E, 0x6B, 0x19, 0xEC, 0x69, 0x7A, 0xF0, 0xC6, + 0xC3, 0x7D, 0x49, 0x89, 0x43, 0xCC, 0x2C, 0x20, 0x2E, 0xB8, 0x5D, 0xCC, 0xDB, 0x39, 0xCB, 0x0B, + 0x76, 0xD8, 0xAC, 0xD6, 0x2A, 0x76, 0x59, 0x7F, 0x6A, 0x1B, 0xCD, 0x4A, 0x93, 0xCA, 0x42, 0x5F, + 0xC7, 0x98, 0xFA, 0xC9, 0x30, 0x2E, 0x9F, 0x8F, 0xE5, 0xB5, 0x37, 0x41, 0x19, 0xF4, 0xA0, 0xE5, + 0xDA, 0x7D, 0x3C, 0xF5, 0x61, 0xCC, 0x98, 0x27, 0xED, 0xE4, 0x5C, 0x0E, 0x7C, 0x1B, 0x33, 0x38, + 0x77, 0x20, 0x92, 0xC9, 0xD3, 0x38, 0xC3, 0x03, 0x2C, 0xAF, 0xE2, 0x77, 0x34, 0x4B, 0xE2, 0x1C, + 0x9F, 0xE4, 0x4D, 0xAB, 0x12, 0xFE, 0xCD, 0xB3, 0x2C, 0xD3, 0xE2, 0x42, 0xB8, 0xE7, 0xE0, 0x14, + 0x88, 0x31, 0xB1, 0xDC, 0x35, 0xDE, 0xCD, 0x3D, 0x3B, 0xDF, 0x6C, 0x00, 0xA3, 0x48, 0xA6, 0x71, + 0x7E, 0xC6, 0x3A, 0xE8, 0x07, 0xCE, 0xC8, 0xE7, 0xDC, 0xB1, 0x98, 0x17, 0xDB, 0x75, 0x20, 0xFE, + 0x38, 0xC7, 0x1F, 0x02, 0x8E, 0xE4, 0x91, 0x79, 0x3D, 0xC0, 0x50, 0x2D, 0xC7, 0x49, 0x33, 0x6C, + 0xDF, 0x3C, 0xE9, 0x42, 0xE9, 0x27, 0xBC, 0x39, 0x38, 0xAA, 0x98, 0x16, 0x6E, 0x1F, 0x71, 0xDF, + 0x3B, 0xBA, 0x15, 0x2F, 0x69, 0xEB, 0x06, 0x5C, 0xFB, 0xF8, 0x4C, 0x83, 0x2C, 0x28, 0xC2, 0x19, + 0xAD, 0x04, 0xA1, 0xB0, 0x7F, 0xF1, 0x9C, 0x84, 0x38, 0x42, 0x45, 0x3E, 0x1E, 0xC7, 0x95, 0xD5, + 0xAF, 0x35, 0x7E, 0x2A, 0xCC, 0x06, 0x9D, 0x9A, 0xCF, 0xC2, 0x56, 0xE6, 0x73, 0x7F, 0x7E, 0x9D, + 0x9B, 0x01, 0x27, 0x76, 0x14, 0x8C, 0x3E, 0x3A, 0xBD, 0x2E, 0x6C, 0x7C, 0xB7, 0xF2, 0x9A, 0x92, + 0x41, 0xBC, 0xD0, 0x48, 0xF6, 0xE6, 0x16, 0x62, 0x01, 0x4D, 0x3D, 0x8E, 0xD2, 0x98, 0x8F, 0x61, + 0x70, 0x7C, 0x41, 0xCC, 0xCA, 0x3D, 0x3E, 0x0B, 0x70, 0xC3, 0x9F, 0x9D, 0x3E, 0x33, 0x50, 0x2B, + 0xB0, 0x47, 0xC8, 0xA3, 0xAA, 0x55, 0xBA, 0x16, 0x3B, 0xF4, 0x07, 0x98, 0x1B, 0x6C, 0x49, 0x6A, + 0xA5, 0xB4, 0x7A, 0xBE, 0x28, 0x37, 0xF2, 0x55, 0x69, 0x09, 0x7A, 0xEC, 0x94, 0x1C, 0x60, 0xE3, + 0xB5, 0x89, 0x07, 0x58, 0x43, 0xA3, 0x3F, 0x1D, 0x94, 0x20, 0x49, 0x5E, 0xC1, 0xB7, 0x4E, 0x2C, + 0x75, 0x95, 0x54, 0x91, 0x4A, 0x01, 0x90, 0xF8, 0xF1, 0x81, 0xC6, 0x4C, 0x9A, 0x63, 0x20, 0x55, + 0x65, 0x8D, 0x30, 0xA2, 0xD4, 0xC7, 0xAF, 0x18, 0xA5, 0x83, 0xB6, 0x68, 0x1B, 0x35, 0x13, 0x6D, + 0xC6, 0x77, 0x5A, 0x04, 0xFB, 0xD5, 0xBD, 0x2B, 0x0D, 0x55, 0x5E, 0xEC, 0x7A, 0x80, 0x17, 0x01, + 0x9C, 0x4F, 0x55, 0x39, 0x57, 0x9F, 0x31, 0x9E, 0xB9, 0xB1, 0x35, 0xD5, 0x2F, 0xB9, 0xF3, 0x6A, + 0x9C, 0x30, 0xEA, 0x1B, 0xE9, 0x34, 0x4A, 0x2F, 0xB1, 0x36, 0x9C, 0xF0, 0x8A, 0xE9, 0x62, 0xDB, + 0x06, 0x32, 0x64, 0x39, 0x58, 0x29, 0xBD, 0xB1, 0x2C, 0x06, 0x56, 0x54, 0xAF, 0x6B, 0x97, 0x5A, + 0x7D, 0x49, 0xB6, 0xDF, 0x06, 0xFC, 0x9F, 0x06, 0x64, 0x89, 0xF5, 0xF4, 0xC4, 0x55, 0x02, 0x19, + 0xAA, 0xC9, 0x1D, 0x8A, 0x5E, 0x3D, 0xA7, 0x13, 0xEC, 0x52, 0x29, 0x8B, 0x6E, 0xC5, 0xA0, 0x62, + 0x9E, 0x89, 0x96, 0xDF, 0x5E, 0x74, 0x69, 0x53, 0x75, 0xCA, 0xF0, 0x95, 0x0E, 0xF8, 0x42, 0xB6, + 0x06, 0x62, 0xDA, 0x92, 0x48, 0xC3, 0x37, 0x50, 0x59, 0xDF, 0x59, 0xAF, 0xAF, 0x0E, 0x2E, 0x84, + 0xE5, 0x2F, 0x3C, 0xC9, 0x7E, 0x2A, 0xE5, 0xA9, 0x41, 0xB1, 0x51, 0x82, 0xC6, 0x42, 0xEC, 0x65, + 0xFD, 0xCB, 0x54, 0x29, 0x33, 0xC2, 0xE5, 0x5E, 0x10, 0xFB, 0x9E, 0x19, 0xE2, 0x75, 0x53, 0x43, + 0x50, 0xD5, 0x10, 0x8E, 0xBC, 0xC6, 0x2A, 0x0A, 0x8D, 0x7F, 0x4A, 0xF6, 0x07, 0x28, 0xA1, 0xEB, + 0x14, 0x1C, 0xD3, 0xE9, 0x63, 0x55, 0xC7, 0xD2, 0xE8, 0xB2, 0x3D, 0x17, 0x84, 0x63, 0xF9, 0x11, + 0xA4, 0x11, 0xE0, 0xA1, 0x83, 0x11, 0x11, 0xD2, 0xA0, 0x8C, 0x61, 0x74, 0x36, 0x63, 0xE9, 0xE8, + 0x98, 0x4C, 0x20, 0x38, 0x1F, 0xA5, 0x15, 0x60, 0x3E, 0x5C, 0x1B, 0xE6, 0xDE, 0xC1, 0x70, 0x7F, + 0xCB, 0x92, 0x76, 0x05, 0xD8, 0x63, 0xDF, 0x01, 0x7E, 0xF2, 0xF1, 0x01, 0xBD, 0xCE, 0x9A, 0x1E, + 0x50, 0x7F, 0xB4, 0xF4, 0x49, 0x5D, 0x7F, 0xCA, 0x86, 0x83, 0x2F, 0x63, 0x33, 0xEF, 0x4F, 0x35, + 0xA1, 0xBF, 0xB6, 0xCD, 0x25, 0xBA, 0x0E, 0xB9, 0xA3, 0x96, 0x41, 0xD4, 0x90, 0xFF, 0xEB, 0xF7, + 0x4F, 0x93, 0xC8, 0xD7, 0x04, 0x62, 0x6E, 0x88, 0xD7, 0x71, 0x0E, 0x0E, 0x37, 0x50, 0xCE, 0xFA, + 0x9B, 0xBD, 0x5B, 0xB0, 0xB7, 0x0F, 0x70, 0x75, 0x0A, 0x5D, 0xFC, 0x69, 0xB3, 0x07, 0x11, 0x9B, + 0xE8, 0x13, 0x0D, 0xBF, 0x08, 0x33, 0x59, 0x20, 0x4A, 0xBD, 0x27, 0x76, 0xED, 0xF2, 0x36, 0x0B, + 0xEA, 0xBC, 0x78, 0x17, 0xBD, 0x6E, 0x4F, 0x37, 0xD3, 0x26, 0x86, 0x85, 0xB1, 0x71, 0xEA, 0x55, + 0x73, 0xAA, 0x7C, 0xA2, 0x36, 0x75, 0xD2, 0xCD, 0xE4, 0xFC, 0xE7, 0xCE, 0x5E, 0xB1, 0xE5, 0xF4, + 0x65, 0xD7, 0x8F, 0x34, 0x07, 0x66, 0xA7, 0x4B, 0xCE, 0x55, 0xB0, 0x71, 0xFD, 0x20, 0x03, 0x5C, + 0xBA, 0x28, 0x0B, 0x71, 0x4D, 0x93, 0xB9, 0x77, 0x5E, 0x46, 0x6A, 0xCB, 0xD7, 0x0A, 0x59, 0x2E, + 0x26, 0x49, 0x0A, 0x36, 0x0F, 0x03, 0x6F, 0x32, 0xD7, 0xF0, 0xEC, 0x53, 0xF6, 0x0B, 0x1E, 0x08, + 0x27, 0x37, 0x69, 0xC5, 0x9F, 0x6C, 0x76, 0x27, 0x4C, 0x7A, 0x7C, 0xB7, 0xC8, 0x1B, 0xC4, 0x79, + 0xA1, 0xE3, 0xE0, 0xF3, 0x3B, 0x20, 0x07, 0x0C, 0xE4, 0xAB, 0x10, 0x6F, 0xA4, 0xFA, 0x7F, 0x08, + 0x6F, 0x5C, 0xAE, 0x06, 0xC5, 0x6D, 0x09, 0x1E, 0x2D, 0xDD, 0x80, 0xA7, 0x7B, 0x9E, 0xE6, 0x44, + 0x79, 0x3D, 0x55, 0x12, 0x51, 0x87, 0x4D, 0x4A, 0x66, 0x32, 0x2D, 0x4E, 0x17, 0x30, 0xAF, 0x77, + 0x7A, 0x8B, 0x44, 0x8D, 0xA4, 0xF8, 0x70, 0xC1, 0x99, 0x55, 0x3D, 0x4B, 0x08, 0x40, 0x2F, 0xA2, + 0xEA, 0xAA, 0x94, 0x24, 0xC3, 0xBD, 0x5C, 0x68, 0x35, 0x8D, 0x71, 0xA8, 0x3E, 0xBA, 0x00, 0x70, + 0x28, 0xB8, 0x10, 0x20, 0x8F, 0x5C, 0xE4, 0xC4, 0xBB, 0x22, 0x59, 0xA2, 0x35, 0x5F, 0x7A, 0x3D, + 0xF1, 0x24, 0x70, 0x1C, 0xE3, 0x3E, 0xED, 0x26, 0x07, 0xD7, 0x82, 0x4B, 0x80, 0x3B, 0x0C, 0xE4, + 0xAB, 0xCF, 0x71, 0x97, 0x87, 0x22, 0x2B, 0x53, 0x27, 0x99, 0x29, 0x10, 0x41, 0x30, 0xE8, 0x28, + 0xD2, 0x48, 0xAC, 0x25, 0x40, 0xBF, 0xDB, 0xED, 0x3A, 0xF4, 0x5D, 0x6E, 0x66, 0x1A, 0x08, 0xFF, + 0xEE, 0x49, 0x36, 0xD7, 0x68, 0x1E, 0xD7, 0xAB, 0xEC, 0xD6, 0x84, 0x1C, 0x8D, 0x35, 0x2D, 0x10, + 0x3C, 0x9C, 0x77, 0x12, 0xB3, 0x09, 0x5F, 0x0B, 0x2A, 0xB3, 0xCF, 0x8E, 0xE0, 0xF1, 0xAA, 0x71, + 0xB1, 0xE3, 0x58, 0x5C, 0xFF, 0xD1, 0x34, 0xE0, 0xBF, 0x20, 0x6D, 0x42, 0x86, 0xCA, 0x97, 0x1B, + 0x76, 0x2F, 0x08, 0x29, 0xEC, 0xD5, 0xDD, 0x04, 0x36, 0xFC, 0xCA, 0x39, 0xBE, 0x28, 0x8C, 0x1F, + 0x0D, 0x56, 0x77, 0xB7, 0xE0, 0x23, 0x41, 0x1E, 0xB4, 0x29, 0x17, 0x7A, 0xAF, 0xF9, 0x30, 0xCF, + 0xF1, 0xFE, 0xF4, 0x62, 0x32, 0xD9, 0xDB, 0x56, 0x9A, 0x2B, 0x31, 0xBF, 0xA5, 0x15, 0x19, 0x1E, + 0xEA, 0xCB, 0x5D, 0x6B, 0x65, 0x9A, 0x06, 0x1F, 0x9C, 0x0E, 0xC0, 0x5D, 0x8C, 0xFB, 0xD5, 0xCF, + 0xA4, 0x18, 0xA1, 0x0C, 0xAD, 0xD3, 0x98, 0x09, 0x3A, 0x86, 0x7F, 0x1C, 0x60, 0xC9, 0xFB, 0x42, + 0xF2, 0x37, 0x4E, 0xF0, 0x91, 0x02, 0x33, 0x41, 0xDE, 0xDB, 0xF8, 0x8E, 0x44, 0x00, 0xC5, 0x94, + 0x21, 0x39, 0x91, 0x0A, 0xB5, 0xC4, 0x44, 0xAC, 0x04, 0xF8, 0xB7, 0xA1, 0x13, 0x70, 0xA7, 0xEF, + 0x23, 0xBD, 0xF6, 0x12, 0x34, 0x30, 0x3A, 0x70, 0x81, 0x21, 0xE7, 0x66, 0xB8, 0x55, 0x00, 0xAF, + 0xC1, 0xC3, 0x56, 0x3D, 0xAB, 0x3D, 0xCA, 0x16, 0x4F, 0x6B, 0x3E, 0x69, 0xEF, 0xF8, 0xCA, 0x7B, + 0x65, 0x1C, 0xF3, 0xD9, 0xE8, 0xB0, 0xF6, 0xF3, 0x18, 0x9E, 0xDF, 0x45, 0xC7, 0xAF, 0xCE, 0xC8, + 0x5E, 0x51, 0x94, 0x76, 0x23, 0x80, 0xF8, 0x49, 0x9B, 0xB9, 0x7C, 0x2F, 0x3C, 0xE6, 0xB5, 0x2F, + 0xAD, 0xCC, 0xE7, 0xE7, 0x1E, 0x08, 0xBF, 0xFA, 0x70, 0x2C, 0xB3, 0xED, 0x0C, 0x29, 0x7D, 0xB0, + 0xBE, 0xE7, 0x91, 0x39, 0x73, 0xC2, 0x80, 0x77, 0x2F, 0x91, 0x1D, 0x2F, 0x45, 0x1E, 0x41, 0xE4, + 0x45, 0x2A, 0x7E, 0x93, 0xCE, 0x6D, 0x65, 0x18, 0x76, 0x61, 0x15, 0x05, 0x24, 0x0E, 0x65, 0xD6, + 0x19, 0x7A, 0xFF, 0x02, 0x94, 0xFB, 0x2D, 0x14, 0xE4, 0xA3, 0x9C, 0xFC, 0x48, 0x29, 0x3A, 0x7F, + 0x36, 0x4F, 0x18, 0xD5, 0x5B, 0x99, 0x4C, 0x97, 0x20, 0x36, 0x77, 0xA6, 0x75, 0xE3, 0x44, 0x92, + 0x47, 0x72, 0xEA, 0x1D, 0x00, 0x5A, 0x1D, 0xAF, 0x12, 0xAC, 0x26, 0xE9, 0x1E, 0x4C, 0x89, 0xCC, + 0x56, 0x01, 0x22, 0x4D, 0x45, 0x44, 0xAC, 0xB6, 0x75, 0xEF, 0x3F, 0x2B, 0x35, 0xC6, 0x06, 0x12, + 0xF6, 0xDB, 0xF1, 0x55, 0xF7, 0x05, 0xB0, 0xC0, 0x16, 0x13, 0x60, 0xAA, 0x01, 0x68, 0x1A, 0xCF, + 0xA3, 0xDE, 0xC2, 0xED, 0x60, 0xB9, 0x38, 0x0A, 0x78, 0x7C, 0x5A, 0x96, 0x70, 0x3E, 0x1E, 0xDC, + 0xCD, 0x80, 0xDE, 0x5B, 0x63, 0x94, 0x01, 0x9D, 0x68, 0x02, 0xB9, 0x64, 0xBC, 0x89, 0xCA, 0xB4, + 0x12, 0xD7, 0x5E, 0x20, 0xC7, 0xBD, 0x39, 0x21, 0xAD, 0x74, 0x3A, 0x04, 0x8F, 0x5F, 0xE2, 0x55, + 0xE2, 0xA4, 0x8F, 0xE0, 0xFB, 0x9D, 0xBD, 0x67, 0xCF, 0xD8, 0x93, 0x6C, 0x84, 0xE7, 0xB6, 0xCE, + 0xBD, 0x7B, 0xDA, 0x93, 0x18, 0x70, 0x6B, 0x48, 0xBA, 0x0E, 0x66, 0x09, 0x2E, 0x91, 0x55, 0x38, + 0x84, 0x02, 0x18, 0x1D, 0x49, 0xDE, 0x25, 0xB3, 0x7E, 0xE8, 0xD0, 0x6E, 0xDD, 0x13, 0x8F, 0xA4, + 0x95, 0x17, 0x01, 0x0D, 0x93, 0xB0, 0xD8, 0xBD, 0x0C, 0xCA, 0x48, 0x62, 0xFA, 0xF5, 0xEA, 0xC5, + 0x71, 0x21, 0x00, 0xEC, 0x3A, 0x88, 0x26, 0xA1, 0x52, 0xBA, 0xBF, 0x2A, 0x70, 0xEB, 0xF7, 0x2B, + 0x43, 0xF4, 0xF6, 0xE3, 0xD0, 0x63, 0x1A, 0xA1, 0x0C, 0x00, 0xFE, 0xF9, 0x12, 0xE1, 0xED, 0x2A, + 0xFD, 0x19, 0x4E, 0x51, 0x22, 0xA0, 0x4C, 0x09, 0x2F, 0x0B, 0x8A, 0x57, 0xFA, 0x3E, 0xF3, 0x02, + 0xE3, 0xF0, 0x8F, 0x17, 0x6E, 0xC1, 0x45, 0x34, 0x95, 0x61, 0x22, 0x9E, 0x72, 0xA9, 0x50, 0x77, + 0x07, 0x64, 0xEE, 0x52, 0x03, 0x10, 0xBA, 0x09, 0xF9, 0x45, 0x29, 0x58, 0x46, 0x24, 0xE7, 0x0F, + 0x21, 0xE0, 0xC8, 0xC8, 0x69, 0xCB, 0x4C, 0xD8, 0x39, 0x0E, 0x0C, 0x24, 0x68, 0x46, 0x1E, 0xD9, + 0x7A, 0x8C, 0xB2, 0x91, 0xF4, 0x1B, 0x96, 0xDE, 0x63, 0xFF, 0xE7, 0xCB, 0x86, 0x9F, 0xCD, 0xFB, + 0xBF, 0x67, 0xBE, 0x46, 0xF7, 0x0E, 0x1F, 0x1D, 0x77, 0x4F, 0x66, 0x4F, 0x4F, 0x09, 0x4E, 0x79, + 0x33, 0x80, 0x66, 0xA5, 0xD0, 0x47, 0xAD, 0x50, 0x3D, 0x45, 0xE5, 0x15, 0xCB, 0x05, 0xA9, 0xC8, + 0xFB, 0x0F, 0x00, 0xB6, 0x9F, 0xF7, 0xC2, 0x1B, 0x15, 0x2B, 0xD1, 0x01, 0xA2, 0x5A, 0xFB, 0x26, + 0x3D, 0x9E, 0xAC, 0x37, 0x2C, 0x0B, 0x3A, 0xD3, 0xE8, 0x99, 0xAF, 0xB0, 0x12, 0x17, 0x06, 0x0C, + 0x7B, 0xF1, 0x6D, 0xB5, 0x8D, 0x18, 0xE4, 0x32, 0x3F, 0x51, 0xC2, 0x20, 0x20, 0xC6, 0x47, 0x22, + 0x08, 0x94, 0x32, 0x99, 0x17, 0x4A, 0x50, 0x36, 0x1E, 0xA2, 0x88, 0xCE, 0x01, 0xAF, 0x78, 0xF5, + 0x6B, 0xF2, 0xA2, 0x0C, 0x8E, 0xC5, 0xE4, 0x31, 0x9C, 0x28, 0xA4, 0x7F, 0x4E, 0x64, 0x1D, 0xF5, + 0xC1, 0x1A, 0x68, 0xE2, 0xF4, 0x3A, 0x99, 0xBC, 0xD3, 0x31, 0xF9, 0xD8, 0x58, 0x7B, 0xB1, 0xB7, + 0x7D, 0x57, 0x2B, 0x7D, 0xAC, 0x4A, 0x43, 0x9E, 0xB2, 0x50, 0x96, 0x06, 0x99, 0x17, 0x89, 0x6A, + 0xA7, 0x2E, 0xC2, 0xB9, 0xA2, 0xBB, 0x96, 0xD4, 0x03, 0xD5, 0xF2, 0xB4, 0xA7, 0x78, 0xE6, 0x65, + 0x31, 0xD2, 0x43, 0x75, 0x4A, 0xD1, 0xB5, 0xE6, 0x07, 0x98, 0x27, 0xAA, 0xBD, 0xCD, 0x32, 0xF1, + 0x80, 0xCE, 0x9E, 0xCD, 0xF2, 0xA1, 0x50, 0xD0, 0x88, 0x02, 0xF0, 0x1C, 0x10, 0x70, 0xAA, 0xA5, + 0xDF, 0x70, 0x32, 0x7E, 0x89, 0xAE, 0x51, 0x37, 0x84, 0x13, 0x18, 0xCE, 0x7D, 0x4C, 0x8A, 0x16, + 0x99, 0xA2, 0x42, 0x9D, 0x5D, 0x9C, 0x81, 0x86, 0x4D, 0x15, 0x96, 0xF0, 0xE6, 0xE1, 0x38, 0x11, + 0xA6, 0x8A, 0x15, 0x14, 0xF7, 0x13, 0xAD, 0x33, 0x81, 0xB5, 0xF4, 0x65, 0x87, 0x87, 0x6F, 0x97, + 0x2F, 0x5D, 0xED, 0xEC, 0xA7, 0xB6, 0x91, 0xE2, 0xF3, 0x7B, 0xE5, 0xC8, 0x7E, 0x3A, 0x26, 0x54, + 0x9C, 0xC3, 0xD3, 0x6C, 0x4B, 0x6A, 0x78, 0x48, 0xF3, 0x0E, 0xCF, 0xBF, 0x9A, 0xC8, 0x60, 0x46, + 0x0B, 0x6C, 0x92, 0x6B, 0x88, 0x6F, 0x42, 0x39, 0xB0, 0xC2, 0x43, 0x8D, 0xA6, 0x4A, 0xF8, 0xF5, + 0x1E, 0x23, 0x74, 0xF7, 0x15, 0xB2, 0x15, 0xEB, 0x5A, 0x2A, 0xCA, 0xA5, 0x2C, 0xCC, 0x3C, 0x7D, + 0x63, 0x65, 0x7F, 0x3A, 0xA8, 0x35, 0xB0, 0x77, 0x54, 0x1A, 0xCB, 0xA5, 0x07, 0x1E, 0x2C, 0x60, + 0x3C, 0x66, 0x32, 0x55, 0x75, 0xEB, 0x57, 0x35, 0xE2, 0xD3, 0xC2, 0x73, 0x5D, 0xF7, 0xC2, 0xB6, + 0xEE, 0x45, 0x1C, 0x19, 0xE6, 0xF9, 0x23, 0x24, 0x23, 0xBA, 0x77, 0x6B, 0x93, 0x73, 0xA0, 0x9C, + 0xF9, 0xF0, 0x59, 0xE7, 0xB4, 0x60, 0xC3, 0xA6, 0x01, 0xEA, 0xC7, 0x52, 0x2B, 0xDC, 0xDC, 0x96, + 0x0F, 0x3C, 0xB0, 0x19, 0x19, 0xE1, 0x52, 0xB6, 0x17, 0x91, 0x2A, 0x4D, 0xC3, 0xFC, 0x44, 0x33, + 0x5F, 0x9D, 0x36, 0x51, 0x3C, 0x02, 0x6D, 0x68, 0x23, 0x64, 0x1B, 0xA0, 0xA3, 0xD7, 0xEA, 0x64, + 0x60, 0xB9, 0xEB, 0xC5, 0x3F, 0xB5, 0x52, 0xC8, 0xC4, 0xC8, 0x73, 0x36, 0x73, 0x28, 0x67, 0xF1, + 0x2A, 0x3C, 0xA6, 0x8A, 0xDB, 0x99, 0x81, 0x90, 0xDF, 0xD7, 0x4C, 0x1F, 0xD1, 0xD9, 0x0D, 0xCE, + 0x6C, 0xD8, 0x8A, 0x03, 0xB4, 0x70, 0x3A, 0x07, 0x2E, 0x2E, 0x5E, 0xA5, 0x5C, 0xBF, 0x51, 0x36, + 0x97, 0x42, 0xA5, 0x76, 0x2A, 0xCA, 0x0A, 0x51, 0x5D, 0x06, 0x78, 0x0E, 0xCF, 0x9E, 0x93, 0x59, + 0x5C, 0x17, 0x05, 0xB6, 0xF2, 0x0D, 0x02, 0xD6, 0x2D, 0x2E, 0x20, 0x62, 0x8D, 0xF7, 0x38, 0xE0, + 0xC1, 0x5E, 0x17, 0x72, 0x4D, 0xA4, 0x2F, 0x5B, 0xDC, 0xC6, 0x40, 0x82, 0x34, 0x04, 0x39, 0x69, + 0xF8, 0xBC, 0xB1, 0x79, 0x54, 0xD5, 0x1E, 0x2D, 0xD8, 0x8C, 0x90, 0x8D, 0xB4, 0xE3, 0x61, 0xB7, + 0x1D, 0xA2, 0x3C, 0xFB, 0x6A, 0x38, 0x98, 0x06, 0xDA, 0x56, 0x2C, 0xBF, 0x9B, 0x14, 0x76, 0xE6, + 0x3C, 0x01, 0x57, 0xCC, 0xC2, 0x08, 0x0C, 0xBC, 0x10, 0x09, 0x67, 0xAB, 0x01, 0x2A, 0x32, 0x6C, + 0x81, 0x2C, 0xAB, 0xD3, 0xEC, 0x7D, 0x87, 0x48, 0x16, 0x28, 0xAC, 0x1D, 0x61, 0x11, 0x31, 0x87, + 0xD6, 0x2B, 0xB0, 0x36, 0xB1, 0x18, 0xDD, 0xE7, 0xD0, 0x46, 0x57, 0x93, 0xFC, 0xDF, 0xD2, 0x3A, + 0x37, 0x49, 0x42, 0xDB, 0xE6, 0x45, 0x46, 0x22, 0xB0, 0xF2, 0x92, 0xEE, 0x52, 0x94, 0x9F, 0xFE, + 0xB1, 0xD2, 0x33, 0x45, 0xAD, 0xC9, 0x6D, 0x11, 0x79, 0x57, 0xF1, 0x80, 0xF4, 0x07, 0xAE, 0xDF, + 0x11, 0x6C, 0x85, 0x58, 0x49, 0x2F, 0x13, 0x81, 0xB9, 0x66, 0x73, 0xAB, 0x84, 0x94, 0x36, 0xC4, + 0xC6, 0x23, 0x5F, 0xC5, 0x36, 0xC6, 0xBE, 0x8E, 0x6B, 0xE9, 0x97, 0xF0, 0xAC, 0xB4, 0xF1, 0x11, + 0x43, 0xB4, 0xD2, 0xC0, 0x79, 0x5E, 0x88, 0x72, 0xC7, 0x46, 0x6B, 0x22, 0xC7, 0xF2, 0x7B, 0x61, + 0xC8, 0xFA, 0x39, 0x65, 0x45, 0x97, 0xF0, 0xC7, 0xCE, 0x74, 0x09, 0x9F, 0x5D, 0xB7, 0x68, 0xF2, + 0x2E, 0x6E, 0x2D, 0x42, 0x56, 0x9C, 0xED, 0xC5, 0x5A, 0x57, 0xD9, 0x53, 0x5A, 0xB4, 0xE8, 0x15, + 0x07, 0x1B, 0xFB, 0x31, 0x40, 0x14, 0x95, 0x77, 0x33, 0x74, 0x71, 0x73, 0x7B, 0xFA, 0xA7, 0xBF, + 0x51, 0xF8, 0x3D, 0xE6, 0xB1, 0xD0, 0x42, 0x25, 0x52, 0xFC, 0x4F, 0x1A, 0xA6, 0x4D, 0xAF, 0xCD, + 0x13, 0x62, 0x7A, 0xBF, 0x22, 0x98, 0xD6, 0x07, 0x9C, 0xAE, 0x5E, 0xFC, 0x96, 0xEC, 0x0E, 0x79, + 0x84, 0x1F, 0x73, 0x60, 0x6C, 0x02, 0x6C, 0xE5, 0xB7, 0xFD, 0x7A, 0x4B, 0x8D, 0x0D, 0xC0, 0xD7, + 0x0A, 0x70, 0x6E, 0xE1, 0x51, 0x0E, 0x8C, 0xAA, 0x02, 0x6A, 0xCF, 0x61, 0x04, 0xBD, 0x53, 0x9D, + 0xE0, 0xB5, 0x28, 0x1E, 0x24, 0xBA, 0x97, 0x13, 0x0C, 0x6E, 0x93, 0x71, 0xE2, 0x68, 0xEC, 0x73, + 0x2C, 0xEC, 0x80, 0xB2, 0x16, 0xD5, 0x38, 0xC6, 0x3B, 0xCE, 0xEB, 0xB9, 0x42, 0xBE, 0x37, 0xB5, + 0x39, 0x31, 0x00, 0x5F, 0xB6, 0xD1, 0xB6, 0xD9, 0x57, 0x34, 0x82, 0x12, 0x07, 0x05, 0x04, 0x4B, + 0x5E, 0xB8, 0xC7, 0x6F, 0xA3, 0x01, 0xB9, 0x1D, 0xFF, 0x5F, 0x52, 0xBF, 0x6E, 0x7B, 0xA8, 0xC3, + 0x6E, 0xAC, 0x00, 0xCD, 0x0A, 0xAB, 0x7D, 0x4E, 0x63, 0x43, 0xCE, 0x10, 0x21, 0x38, 0x42, 0x88, + 0x8D, 0xA7, 0x46, 0x7F, 0x74, 0x1F, 0x1D, 0x5F, 0x25, 0xD2, 0xC0, 0x18, 0x7D, 0x40, 0x61, 0x36, + 0x06, 0xB5, 0x09, 0xCA, 0xC6, 0xAD, 0xD6, 0x9E, 0xED, 0x45, 0xF6, 0x95, 0x32, 0x07, 0x84, 0x71, + 0xC8, 0x35, 0xB0, 0x81, 0x97, 0xC9, 0x60, 0xDE, 0xFD, 0x8E, 0x90, 0x67, 0xD7, 0x23, 0x51, 0x28, + 0x90, 0xA5, 0x6E, 0xB6, 0x59, 0x88, 0xD1, 0x8D, 0xCD, 0x17, 0xA3, 0x48, 0xE3, 0x3F, 0x00, 0x4E, + 0x9B, 0x21, 0xD5, 0xA4, 0x5A, 0xF0, 0xA0, 0xBA, 0x40, 0xB7, 0xBB, 0xE1, 0x3D, 0x16, 0x9E, 0xEE, + 0xBB, 0x9E, 0xB2, 0x91, 0xBD, 0x39, 0x77, 0xD6, 0xB5, 0x9C, 0xB5, 0xE8, 0xCF, 0x7D, 0x8C, 0x83, + 0x82, 0x1A, 0xBA, 0x11, 0xDA, 0xF3, 0x96, 0xDD, 0x09, 0x20, 0x9F, 0xEB, 0xAE, 0x39, 0xAC, 0x7C, + 0xF2, 0x41, 0x98, 0x21, 0x6B, 0x8D, 0x19, 0xFF, 0x36, 0x5E, 0x82, 0xAC, 0xEE, 0x1E, 0x0E, 0x77, + 0x63, 0x14, 0x4E, 0x87, 0xE8, 0x22, 0x01, 0xD4, 0xC4, 0xF3, 0xE6, 0x49, 0xE6, 0x25, 0x64, 0x5C, + 0x54, 0x4B, 0x10, 0xE7, 0xCD, 0x17, 0x8F, 0xFA, 0xA3, 0x4D, 0xCA, 0x49, 0xCA, 0x4D, 0x33, 0xBC, + 0x29, 0x71, 0x4D, 0xF9, 0x0D, 0x74, 0x01, 0xAC, 0x79, 0xA7, 0xD7, 0x75, 0xD3, 0x9B, 0x04, 0xEE, + 0xCB, 0xCD, 0x51, 0xCC, 0xAA, 0x68, 0xFB, 0x41, 0xD3, 0x2D, 0xC1, 0xC8, 0x72, 0xDC, 0x69, 0xBE, + 0x0A, 0x74, 0xFF, 0xA8, 0x0C, 0xB4, 0xE1, 0x1A, 0xD3, 0x30, 0x21, 0xA9, 0x34, 0xCC, 0xB5, 0xE9, + 0xCF, 0x38, 0x48, 0x3B, 0xFC, 0xD6, 0x88, 0xD8, 0xB7, 0x3D, 0x71, 0xE4, 0x36, 0xA2, 0xE6, 0x03, + 0x02, 0xE3, 0xFB, 0x68, 0x0F, 0x07, 0x3B, 0x80, 0x30, 0x1C, 0xF4, 0x88, 0x0D, 0x86, 0x1F, 0x83, + 0x4D, 0x93, 0xD4, 0x10, 0xB1, 0xFF, 0x2C, 0xCB, 0xBE, 0x8E, 0xA8, 0xDB, 0x09, 0xE5, 0xF7, 0x9C, + 0x82, 0x48, 0xE0, 0xC8, 0x2C, 0x7B, 0xA1, 0x46, 0x89, 0xE9, 0x0D, 0x82, 0x6F, 0xC1, 0xEA, 0xA5, + 0x84, 0x82, 0x33, 0x26, 0x4A, 0xB6, 0x84, 0x60, 0x21, 0x00, 0x89, 0x20, 0x84, 0x14, 0x7A, 0xDF, + 0x7B, 0xEB, 0x45, 0x6B, 0x76, 0xE6, 0xDB, 0x53, 0xBE, 0x6A, 0x95, 0xE1, 0xFE, 0x6A, 0x79, 0x07, + 0xBC, 0x9D, 0xB3, 0x37, 0x67, 0xAF, 0xC2, 0x1E, 0x2B, 0xFF, 0x9F, 0xC5, 0xF5, 0x54, 0xE0, 0x29, + 0x44, 0xA4, 0x2A, 0x6F, 0xB7, 0x52, 0x17, 0x2C, 0xB1, 0x72, 0x6E, 0x9F, 0x30, 0x9D, 0x42, 0x41, + 0xF6, 0xD5, 0x14, 0x3E, 0x32, 0x59, 0x42, 0xAD, 0x7A, 0x68, 0x53, 0xF9, 0x99, 0xFD, 0x30, 0xC0, + 0x68, 0xB6, 0x97, 0xD9, 0x1B, 0x9A, 0xF6, 0xB9, 0x06, 0xE2, 0x2E, 0x27, 0x60, 0xE9, 0x1A, 0xBD, + 0x88, 0xCD, 0xAD, 0xE0, 0xCB, 0xED, 0x76, 0x2B, 0x46, 0x24, 0xB0, 0x48, 0xBA, 0x55, 0x9B, 0xBD, + 0x6D, 0xF2, 0xF7, 0x8C, 0x59, 0x4E, 0xB6, 0xE4, 0x89, 0xE1, 0xD4, 0x97, 0x85, 0x15, 0x27, 0xAE, + 0xD0, 0x9A, 0x72, 0x98, 0xB0, 0x6F, 0x06, 0xB9, 0xFC, 0xFD, 0x0D, 0x51, 0x11, 0x7E, 0x02, 0x66, + 0xD2, 0xE7, 0x25, 0xD4, 0x4D, 0xAE, 0x78, 0x9F, 0x8E, 0x69, 0xDD, 0x43, 0x80, 0x2F, 0xE6, 0x6E, + 0x46, 0xD7, 0x1A, 0x05, 0x8F, 0x4B, 0x5E, 0xF7, 0x4E, 0x09, 0x9B, 0xAF, 0x4E, 0x2B, 0x14, 0x91, + 0x59, 0x67, 0xFF, 0xFF, 0xAA, 0x08, 0xE7, 0x25, 0x42, 0x4E, 0x17, 0xD6, 0xDF, 0xD8, 0x23, 0x45, + 0xB4, 0xE2, 0x15, 0xE8, 0xDB, 0xA8, 0x55, 0x81, 0x9B, 0xE3, 0x3F, 0x09, 0x0C, 0x16, 0x19, 0xE6, + 0xE3, 0x7F, 0x1D, 0xB6, 0xBB, 0x14, 0x3C, 0x58, 0xBB, 0x69, 0x5F, 0x7A, 0x1A, 0x51, 0x45, 0xEE, + 0xDB, 0xA5, 0x7F, 0x53, 0x27, 0x04, 0xA0, 0x60, 0x76, 0x7A, 0xAD, 0x29, 0x7A, 0x8B, 0x49, 0x4C, + 0x6D, 0x26, 0x01, 0x45, 0x9B, 0x2F, 0xC8, 0x6B, 0xE0, 0x11, 0x1E, 0xCE, 0x35, 0x18, 0xDA, 0x6A, + 0x7E, 0x14, 0x56, 0xFB, 0x19, 0xE2, 0xBC, 0xAF, 0xE9, 0x62, 0xF9, 0xD4, 0xB7, 0x21, 0x1D, 0x45, + 0x10, 0xB7, 0xF3, 0x10, 0x80, 0xD0, 0xA9, 0x20, 0x12, 0xFB, 0xFA, 0xB9, 0xF6, 0x9B, 0x32, 0xA9, + 0x68, 0x58, 0xD9, 0x97, 0xDD, 0x4D, 0xDB, 0x67, 0x95, 0x35, 0xFE, 0xFA, 0x9A, 0xB2, 0x8D, 0x39, + 0x32, 0xD0, 0x5F, 0x6E, 0x74, 0x62, 0x3F, 0xC0, 0xC9, 0x24, 0x49, 0xC9, 0x65, 0x27, 0x88, 0x52, + 0x60, 0xBB, 0x6B, 0x52, 0xAC, 0x35, 0x90, 0x47, 0xF8, 0x34, 0xF4, 0x8E, 0x9E, 0x43, 0xE6, 0x28, + 0xA5, 0x04, 0xA9, 0x10, 0x09, 0x4F, 0xE0, 0x2E, 0x3E, 0x12, 0xD9, 0xC3, 0xC3, 0xF0, 0xAB, 0x30, + 0x18, 0x13, 0x6C, 0x17, 0x06, 0x2C, 0x03, 0x60, 0x04, 0x5D, 0x0E, 0xC8, 0x7F, 0x80, 0x4B, 0xAD, + 0xAF, 0x34, 0x2B, 0xDC, 0x94, 0x1F, 0x68, 0x0A, 0xAB, 0xA3, 0xD7, 0x19, 0x23, 0x02, 0x8F, 0xBD, + 0xB9, 0x33, 0xD3, 0x93, 0x66, 0xC9, 0x19, 0x18, 0xEF, 0x08, 0x0C, 0xEE, 0xDB, 0xB3, 0x5E, 0x55, + 0xB2, 0xDC, 0xBB, 0x90, 0x02, 0x2B, 0x90, 0x67, 0x41, 0x3E, 0x65, 0xA0, 0x9B, 0xC4, 0x5D, 0x81, + 0xDC, 0x64, 0x82, 0xA9, 0x86, 0xA7, 0xB1, 0x1C, 0x6C, 0x7B, 0xA2, 0x07, 0xF1, 0xE0, 0x8E, 0x4F, + 0xBF, 0x07, 0x20, 0x48, 0x05, 0xE5, 0x1D, 0xB6, 0xD8, 0x83, 0x45, 0x7C, 0xAD, 0x84, 0x32, 0x94, + 0xCA, 0x88, 0x96, 0xAA, 0x07, 0xE8, 0x7B, 0x0A, 0x89, 0x46, 0x98, 0x2F, 0x93, 0x65, 0xEB, 0x7B, + 0x79, 0x50, 0x8C, 0x8D, 0x01, 0x6D, 0xCE, 0xB4, 0x5E, 0x1E, 0x74, 0x6D, 0xC3, 0x29, 0x0B, 0x34, + 0xB6, 0xB8, 0xE7, 0x9C, 0x2D, 0x71, 0x49, 0x65, 0x07, 0x1A, 0x7D, 0x04, 0x74, 0x42, 0xD7, 0x0D, + 0x96, 0x80, 0x85, 0xFC, 0x5D, 0x29, 0x79, 0x54, 0x8F, 0x08, 0x2A, 0x7F, 0xF2, 0xB8, 0x87, 0x13, + 0x29, 0x6E, 0xC4, 0xB7, 0x99, 0xBB, 0xC5, 0x6C, 0x4D, 0x01, 0x38, 0xB5, 0xFF, 0x93, 0xEC, 0x0F, + 0x96, 0xA5, 0x47, 0x78, 0xD1, 0xC0, 0x63, 0x61, 0xE0, 0x2D, 0xE4, 0x56, 0x7C, 0xAC, 0x77, 0x30, + 0x21, 0x55, 0x32, 0xFD, 0x4E, 0xC0, 0x31, 0x9B, 0x7C, 0x37, 0x04, 0x8B, 0xAB, 0x95, 0x03, 0xAC, + 0x22, 0x9E, 0x1F, 0x86, 0x2A, 0xB5, 0xD9, 0x32, 0x56, 0xCC, 0x4E, 0xE5, 0x1A, 0x70, 0x65, 0x5B, + 0x32, 0xC7, 0x1D, 0x96, 0x73, 0x62, 0x49, 0xB3, 0xC5, 0xA1, 0x83, 0xEB, 0x32, 0x6B, 0x6E, 0x17, + 0xC2, 0xD2, 0xBA, 0x90, 0x3B, 0xB5, 0x99, 0x18, 0x34, 0x4D, 0x15, 0x57, 0x19, 0xCD, 0x3C, 0xE1, + 0xCF, 0x55, 0x4A, 0x44, 0xD0, 0xFD, 0xD1, 0x29, 0xB5, 0x86, 0xA1, 0xAA, 0xB0, 0x6C, 0x30, 0xEE, + 0x14, 0xC2, 0x9E, 0x02, 0x31, 0xDF, 0x13, 0x0D, 0xC6, 0xFA, 0x9F, 0xC1, 0x17, 0xF1, 0x52, 0x08, + 0x8B, 0xBB, 0x81, 0xB8, 0x92, 0x7B, 0x19, 0x0F, 0x5E, 0x7A, 0xDF, 0xEB, 0x86, 0x8C, 0x5F, 0x6C, + 0x7A, 0xE9, 0xF1, 0x26, 0x55, 0x80, 0xFF, 0xBC, 0x6A, 0x0A, 0xBC, 0x23, 0xAB, 0xE8, 0x8E, 0xC3, + 0xA5, 0xD7, 0xFD, 0x52, 0x73, 0x68, 0x4B, 0x56, 0x7F, 0x60, 0x4A, 0x68, 0x84, 0x30, 0xE1, 0x1F, + 0x0C, 0x10, 0x41, 0x71, 0xFC, 0x10, 0xDF, 0x62, 0xCC, 0x4D, 0xD6, 0x2A, 0x7F, 0xB9, 0xAF, 0x46, + 0x94, 0x3A, 0xD7, 0x0F, 0x12, 0x2C, 0xB8, 0x17, 0x1F, 0x56, 0xF3, 0xCD, 0xA0, 0xE7, 0xBF, 0xA4, + 0xFB, 0xC5, 0xE8, 0x17, 0x4B, 0x8A, 0xE5, 0x3E, 0x96, 0x22, 0x17, 0x07, 0xA3, 0x17, 0x0A, 0x77, + 0x98, 0xF8, 0x9B, 0x59, 0x5C, 0x2F, 0xC9, 0x73, 0xA4, 0x5A, 0x17, 0x1F, 0xBD, 0x56, 0x3E, 0xA2, + 0xE6, 0x8F, 0x34, 0xF2, 0xE0, 0x20, 0x37, 0xE4, 0x98, 0xE1, 0xEC, 0xC4, 0x1E, 0x81, 0x13, 0x17, + 0x21, 0x95, 0x88, 0x60, 0x04, 0xDA, 0x91, 0xB9, 0x22, 0xF8, 0x64, 0x87, 0x8D, 0x32, 0x60, 0x37, + 0x33, 0x2E, 0x2B, 0x95, 0x43, 0x0C, 0x10, 0xDF, 0xFC, 0x64, 0x56, 0x89, 0x32, 0x47, 0xA3, 0x8F, + 0xF1, 0x3E, 0x34, 0x63, 0x35, 0xD9, 0x41, 0xD8, 0x1A, 0x23, 0x88, 0x39, 0x6D, 0x23, 0x2A, 0x20, + 0xCE, 0xFB, 0x80, 0x0F, 0x59, 0xB7, 0xFB, 0x1E, 0x24, 0xF5, 0x8A, 0x78, 0x2B, 0xE8, 0x13, 0x52, + 0x34, 0x5B, 0x65, 0x64, 0xAB, 0x78, 0x4D, 0x5C, 0x79, 0x3B, 0xF2, 0x7D, 0x1F, 0x5B, 0xA9, 0x37, + 0xAE, 0x4C, 0x9E, 0x30, 0x6B, 0x39, 0x3D, 0x75, 0x06, 0xCE, 0xFE, 0x87, 0xB7, 0x1B, 0x9C, 0x9F, + 0x44, 0x7E, 0x98, 0xFF, 0x3B, 0xA6, 0x71, 0x48, 0xE3, 0x07, 0x8C, 0x5E, 0x95, 0x96, 0x04, 0xC1, + 0xBF, 0x7A, 0x18, 0x06, 0xC2, 0xD2, 0x24, 0xD6, 0xC9, 0x4D, 0x65, 0xCE, 0x18, 0x8F, 0x8B, 0x0D, + 0xFC, 0x66, 0x40, 0xB1, 0xE6, 0xE5, 0xC5, 0xDE, 0xAE, 0x2E, 0x84, 0x3F, 0xBA, 0x16, 0x5A, 0x63, + 0x72, 0x0F, 0x3C, 0x82, 0x4A, 0xD7, 0x54, 0x54, 0x60, 0x1B, 0x6A, 0x16, 0x2D, 0xDA, 0x0F, 0xF9, + 0x61, 0xD2, 0x53, 0x2B, 0xE4, 0x22, 0x0E, 0x1D, 0x08, 0x69, 0x5D, 0x4D, 0x4D, 0x3E, 0x99, 0xBE, + 0x8A, 0x83, 0xA2, 0x5A, 0x68, 0x8B, 0xBB, 0x6A, 0xA5, 0x31, 0xB9, 0x65, 0xA6, 0x55, 0xD1, 0x09, + 0x8D, 0x6B, 0xAB, 0xD8, 0xF1, 0x06, 0x62, 0xA8, 0x1A, 0xDA, 0xA4, 0x4B, 0x68, 0xA9, 0xB8, 0xA5, + 0x9D, 0xD1, 0xAA, 0x42, 0x8E, 0x67, 0xA8, 0xC6, 0x29, 0x94, 0x69, 0x38, 0xA0, 0x66, 0x84, 0xBB, + 0x73, 0x3B, 0xFC, 0x7D, 0x6B, 0xCD, 0x39, 0x8F, 0x1C, 0x6C, 0xE0, 0x58, 0x97, 0x75, 0xB7, 0x09, + 0x40, 0x68, 0x45, 0xCD, 0x97, 0x78, 0x1A, 0x81, 0xA9, 0x6D, 0x6C, 0x59, 0xB8, 0x0C, 0x7D, 0x94, + 0x46, 0x23, 0xCC, 0xD4, 0x2D, 0x71, 0x95, 0x7F, 0x9F, 0x08, 0xE0, 0xE5, 0xF9, 0xC0, 0x2C, 0xC4, + 0x09, 0x27, 0x7C, 0x62, 0x5E, 0xF4, 0xB6, 0xAA, 0x9D, 0x18, 0x10, 0xCE, 0xCB, 0xCA, 0xFC, 0xC2, + 0x12, 0x5A, 0xC2, 0xC7, 0xFA, 0x47, 0x3B, 0x4A, 0x5C, 0xC7, 0x52, 0xCA, 0x97, 0xD4, 0xC3, 0x90, + 0x1D, 0x04, 0x50, 0x92, 0xFF, 0xCC, 0xA9, 0x85, 0x4D, 0x1F, 0x73, 0xE3, 0x5B, 0x4D, 0x20, 0xCA, + 0x46, 0x89, 0xD5, 0x26, 0x2B, 0xF5, 0x6B, 0x2A, 0x0B, 0x9C, 0x36, 0x15, 0x9A, 0xB2, 0x15, 0xC1, + 0xAF, 0x38, 0x3D, 0xA5, 0x4B, 0x47, 0x56, 0x32, 0x90, 0x60, 0x93, 0x5D, 0x8C, 0xE4, 0x3D, 0x3A, + 0x00, 0xB2, 0x84, 0x92, 0xE7, 0x9C, 0x09, 0xD4, 0x55, 0x01, 0xFC, 0xFC, 0x3C, 0x0B, 0x6B, 0x0B, + 0xD4, 0x39, 0x7B, 0x88, 0x40, 0x08, 0xDE, 0x2D, 0xFC, 0x9E, 0xEF, 0xFE, 0xCA, 0x45, 0xB6, 0x8F, + 0xDD, 0x59, 0x49, 0x16, 0x9B, 0x26, 0x88, 0x7F, 0x83, 0xA0, 0x29, 0x14, 0xA6, 0x96, 0x51, 0x1D, + 0x36, 0xCF, 0x7D, 0x01, 0x2E, 0xC3, 0xC5, 0xC2, 0x49, 0xAB, 0x70, 0xAC, 0x66, 0x08, 0xA4, 0xB7, + 0xB5, 0x37, 0x34, 0xEB, 0xD1, 0xA1, 0x52, 0xB1, 0xF8, 0x1C, 0x88, 0x36, 0x32, 0x00, 0xA4, 0x5B, + 0x3B, 0x93, 0x34, 0x20, 0x5F, 0xA9, 0x9B, 0x1E, 0xA6, 0xF9, 0xFC, 0xC5, 0x34, 0x2E, 0x64, 0xCE, + 0x97, 0x44, 0x71, 0x0D, 0x09, 0x89, 0xF2, 0x68, 0x41, 0xF9, 0x64, 0xA0, 0xFC, 0xE2, 0x43, 0x14, + 0x77, 0xB1, 0x68, 0x2C, 0xE6, 0xCB, 0xD4, 0x82, 0xE0, 0xF1, 0x93, 0x00, 0x50, 0x9F, 0x14, 0x6F, + 0x78, 0xDC, 0x7B, 0xC2, 0xD6, 0x31, 0x29, 0x85, 0xA6, 0xEB, 0x50, 0xEC, 0xA6, 0xDD, 0xAA, 0x50, + 0x65, 0x94, 0xEE, 0x68, 0xC3, 0x11, 0xAA, 0xB7, 0xA7, 0xEE, 0xBB, 0x39, 0x08, 0xA6, 0xE8, 0xC5, + 0x4E, 0x52, 0x84, 0xDD, 0xE6, 0x16, 0xF5, 0xC3, 0xAC, 0xB0, 0xBE, 0x3F, 0xA0, 0xC9, 0x1F, 0x17, + 0xC0, 0x8D, 0x7C, 0x80, 0x27, 0xAE, 0xBB, 0x47, 0x32, 0x94, 0x01, 0xCB, 0x72, 0x12, 0xCB, 0x74, + 0x56, 0x58, 0x17, 0x30, 0x57, 0x6C, 0x94, 0x08, 0xD4, 0x60, 0x50, 0x41, 0x35, 0xAB, 0xBD, 0x0B, + 0xA7, 0x43, 0x1B, 0x53, 0x19, 0xBA, 0x05, 0x67, 0xAF, 0x4C, 0xAD, 0x76, 0xBA, 0x7D, 0x75, 0x8E, + 0x64, 0x0C, 0xDD, 0xFB, 0xD9, 0x84, 0x3F, 0xB0, 0x57, 0x4D, 0x8C, 0xA0, 0x0F, 0xD9, 0xE0, 0x53, + 0xB9, 0x1D, 0xAE, 0xE1, 0xCC, 0x9E, 0xD5, 0x79, 0xDA, 0xB4, 0x0C, 0x0B, 0xDD, 0x95, 0x28, 0xDD, + 0x7F, 0x73, 0x43, 0x83, 0xC5, 0x45, 0x14, 0x00, 0xBA, 0x00, 0x9C, 0xC0, 0xC8, 0x62, 0x34, 0x66, + 0xF9, 0x78, 0x57, 0x0B, 0x9F, 0x85, 0xEE, 0x49, 0xF6, 0xA9, 0x86, 0x05, 0x6B, 0x0E, 0x1F, 0x26, + 0xD0, 0xD9, 0xEB, 0xA8, 0x5B, 0x9B, 0xCD, 0x4E, 0x25, 0x07, 0xE1, 0xE0, 0x60, 0xA0, 0xFB, 0x17, + 0x7C, 0x41, 0xAA, 0x20, 0xFE, 0x83, 0x25, 0x3A, 0x9A, 0x02, 0x87, 0x0A, 0x71, 0x87, 0xE5, 0xD3, + 0xC1, 0xDC, 0x85, 0xC8, 0xFA, 0x71, 0x2A, 0xCF, 0xA1, 0xF7, 0x44, 0x13, 0x9C, 0x03, 0x56, 0xC3, + 0x7A, 0xEE, 0x51, 0x35, 0x3C, 0x27, 0x30, 0xF3, 0x3E, 0x31, 0x5F, 0x00, 0x51, 0xA7, 0x1C, 0x92, + 0xA4, 0xE1, 0xC3, 0x43, 0x12, 0x03, 0x3C, 0xEE, 0xD3, 0xFA, 0x1C, 0x6A, 0x0F, 0xE0, 0x45, 0xBB, + 0x3B, 0x81, 0xF1, 0x37, 0x46, 0x9C, 0x6E, 0x21, 0x74, 0xFA, 0x93, 0x52, 0xF4, 0x57, 0x95, 0x81, + 0xD3, 0x57, 0x44, 0x5E, 0xF0, 0x54, 0x18, 0x3C, 0xFB, 0x3A, 0xE7, 0x10, 0x67, 0xF2, 0x20, 0x24, + 0x09, 0xD2, 0x6D, 0xAB, 0xC2, 0xBA, 0x3C, 0x30, 0xE9, 0x65, 0xF1, 0x50, 0xFB, 0x11, 0xB6, 0xCF, + 0x85, 0x7B, 0x6A, 0x4A, 0x56, 0x59, 0x59, 0xB7, 0xDE, 0xFB, 0xC8, 0x39, 0x6A, 0x52, 0x6D, 0xE6, + 0xB7, 0xC7, 0x7A, 0x62, 0x01, 0x25, 0x3D, 0x54, 0x54, 0xB4, 0xF2, 0xBA, 0xF9, 0xEE, 0xE3, 0x59, + 0xD0, 0x74, 0xB5, 0xBF, 0xDF, 0x3E, 0x3F, 0x87, 0x64, 0x82, 0xD9, 0xD5, 0xF9, 0xE8, 0xBB, 0xC5, + 0xA5, 0x61, 0x91, 0x9C, 0x2C, 0x99, 0xC0, 0x39, 0xB3, 0xEF, 0x33, 0x5E, 0x3E, 0x1E, 0x00, 0xC6, + 0x5A, 0x90, 0x1C, 0x50, 0x43, 0x3D, 0x4B, 0xA1, 0x3F, 0x46, 0xEB, 0xBA, 0x86, 0xA4, 0xEA, 0xE1, + 0xA9, 0x40, 0x97, 0x5A, 0x80, 0x97, 0x36, 0x1C, 0xA8, 0x19, 0x4E, 0x0D, 0xF8, 0xCB, 0x1C, 0xC7, + 0xD4, 0x1C, 0xB1, 0x4C, 0x2E, 0xDB, 0x2D, 0x96, 0x1E, 0xBA, 0xEB, 0x3D, 0xDE, 0x7D, 0xC7, 0x2E, + 0xF8, 0x36, 0x54, 0x5C, 0x94, 0xD0, 0x5A, 0x0E, 0x5D, 0xF6, 0x4D, 0x35, 0xD2, 0xC1, 0x52, 0xC7, + 0x3B, 0x58, 0x43, 0xEB, 0xB6, 0x54, 0xBA, 0xA5, 0xF1, 0x86, 0xDB, 0x23, 0xAB, 0x6A, 0x42, 0x00, + 0x90, 0xD2, 0x0C, 0x76, 0x32, 0xA0, 0xC2, 0xE3, 0x10, 0x0E, 0x0C, 0x8A, 0x7C, 0xA5, 0x5F, 0xC9, + 0x4E, 0x79, 0x6E, 0x38, 0x0D, 0xA1, 0xD8, 0x7E, 0x90, 0xDD, 0xA4, 0x35, 0x33, 0xBF, 0xCE, 0x69, + 0x8F, 0x93, 0xBC, 0xB4, 0xC8, 0xD2, 0xD1, 0xD8, 0x2F, 0x31, 0xF8, 0x0B, 0x12, 0x8B, 0xA2, 0xAA, + 0x7B, 0x36, 0x5F, 0x66, 0x0D, 0xF6, 0x34, 0x0F, 0xA7, 0x6A, 0xF3, 0x52, 0x4A, 0xB3, 0xCE, 0x83, + 0xB5, 0x57, 0x11, 0x74, 0xBF, 0x1D, 0x5E, 0xA4, 0x18, 0x84, 0xC6, 0xE4, 0xAC, 0x42, 0x93, 0x82, + 0x99, 0xF1, 0x4B, 0xE2, 0x07, 0x0E, 0x0C, 0xAD, 0xC4, 0x7E, 0x24, 0xC7, 0xF9, 0x22, 0x34, 0x31, + 0x0B, 0xC9, 0xBF, 0xA8, 0x74, 0xE9, 0xDE, 0xE8, 0x61, 0xDC, 0xC2, 0x49, 0x95, 0x78, 0x6F, 0x2D, + 0x46, 0x76, 0xD8, 0x2F, 0xA9, 0x56, 0x00, 0x38, 0x74, 0x54, 0xBB, 0x66, 0xE5, 0x9B, 0xA1, 0xAB, + 0xE4, 0x1E, 0x46, 0x71, 0x90, 0xC1, 0xF8, 0x16, 0x8A, 0x8F, 0x76, 0xE6, 0x4F, 0x06, 0xE8, 0xE8, + 0xAA, 0x25, 0xF2, 0x75, 0x3A, 0x0D, 0xBD, 0xF6, 0x40, 0xEE, 0x64, 0xE0, 0xF4, 0xD5, 0xBB, 0x76, + 0x7A, 0x8B, 0x43, 0xD8, 0x75, 0xD3, 0xAF, 0x1A, 0xE7, 0x59, 0x5E, 0x8E, 0xC8, 0xE4, 0xD9, 0x7C, + 0x3E, 0x02, 0x4D, 0xBE, 0x00, 0xD9, 0x6F, 0x46, 0xF1, 0x4A, 0x5B, 0x33, 0x97, 0x6E, 0x54, 0x5A, + 0x3A, 0x41, 0x6F, 0xC0, 0xB7, 0x3E, 0x78, 0xE5, 0xCF, 0x75, 0x1C, 0xEE, 0xD8, 0xA1, 0xEE, 0xD0, + 0x37, 0x94, 0xFE, 0x63, 0x1B, 0x2F, 0x63, 0x7A, 0xFE, 0x22, 0xCD, 0x32, 0xE1, 0xB6, 0xF8, 0x21, + 0x33, 0xDA, 0xCE, 0xB4, 0x91, 0x25, 0x21, 0x67, 0xA2, 0x6D, 0x5D, 0x49, 0xBD, 0x77, 0x92, 0x60, + 0xA3, 0x56, 0xBF, 0x1E, 0x1B, 0xF8, 0xE9, 0x40, 0xC5, 0xBF, 0x06, 0xFC, 0x14, 0xBC, 0xBC, 0x62, + 0xC0, 0xCB, 0x8D, 0x67, 0x7E, 0xDD, 0xB9, 0xCE, 0x66, 0xE2, 0x52, 0xC1, 0x21, 0x68, 0x93, 0xB4, + 0x6F, 0xFC, 0x81, 0x1F, 0x41, 0xD7, 0x7F, 0x10, 0xCF, 0x35, 0x9B, 0x72, 0xC6, 0xBC, 0x05, 0x5D, + 0x7D, 0x63, 0x09, 0xB4, 0xA8, 0x62, 0xAA, 0x42, 0x51, 0xC1, 0xC0, 0xF0, 0x2D, 0xE2, 0xBE, 0x6D, + 0x54, 0x53, 0x55, 0x7B, 0x39, 0x0A, 0xB0, 0x2A, 0xE0, 0x45, 0x0A, 0xEF, 0xD7, 0x7E, 0xB9, 0xAF, + 0xB9, 0xDA, 0x22, 0x5D, 0x65, 0xD5, 0x39, 0x0F, 0xE4, 0x2B, 0x8E, 0xAA, 0x79, 0xC9, 0xFB, 0xF0, + 0x00, 0x51, 0xE6, 0x59, 0x3F, 0x12, 0x54, 0x4A, 0x29, 0x23, 0xD3, 0x6A, 0x9F, 0xB9, 0x0D, 0x99, + 0x1E, 0x8A, 0xF6, 0x55, 0xD3, 0xDC, 0x8A, 0x48, 0xC3, 0xE5, 0x16, 0xDA, 0xFF, 0xB0, 0x3B, 0x92, + 0x49, 0xD6, 0x00, 0xB1, 0x13, 0x8E, 0xC2, 0x3F, 0x7C, 0xF9, 0x48, 0x55, 0xD5, 0xAC, 0xEA, 0x8A, + 0xC1, 0x5C, 0xA9, 0x48, 0xEA, 0x71, 0xDA, 0x99, 0xE9, 0x49, 0xBA, 0xD8, 0x1F, 0xF2, 0xB2, 0x51, + 0x5D, 0x13, 0xC7, 0x6A, 0x82, 0x8E, 0x64, 0x3A, 0x11, 0x56, 0x66, 0x24, 0x2D, 0xC1, 0x7D, 0x3A, + 0xB2, 0x45, 0xB6, 0xAE, 0x10, 0x8F, 0xBD, 0xD6, 0x9F, 0xAB, 0x44, 0xA7, 0x4A, 0x5D, 0x92, 0x7D, + 0x8F, 0xE5, 0x59, 0x4A, 0x10, 0x85, 0xFD, 0x3C, 0x40, 0x3B, 0xBF, 0xDF, 0xA7, 0x3A, 0x1D, 0xB5, + 0x67, 0x23, 0xF9, 0xAC, 0x59, 0x31, 0x2F, 0xD9, 0xD6, 0xF5, 0xEA, 0xD1, 0xDE, 0xAE, 0xFA, 0x44, + 0xFD, 0xE0, 0xBE, 0xE3, 0xF7, 0xEA, 0xD5, 0xF0, 0x26, 0x41, 0xE5, 0x3D, 0xBE, 0xAA, 0xFC, 0x57, + 0x49, 0xAE, 0x3E, 0x70, 0x8F, 0x9D, 0xF1, 0xB6, 0x32, 0x7D, 0xE7, 0x21, 0x4A, 0x7E, 0x99, 0xD7, + 0x90, 0xFE, 0xC5, 0xB2, 0xE8, 0xAC, 0x6D, 0xF7, 0x3C, 0xD3, 0x1E, 0x61, 0xF4, 0xFF, 0x8C, 0x13, + 0x5A, 0x7F, 0x87, 0x66, 0x47, 0x84, 0xF8, 0x3B, 0x0B, 0x70, 0xCF, 0xBA, 0x0C, 0x87, 0x93, 0x62, + 0x65, 0x1E, 0x47, 0xFC, 0x96, 0x25, 0x46, 0x01, 0xE0, 0xCE, 0xE2, 0x41, 0xC6, 0x38, 0x90, 0x0D, + 0xE3, 0xC7, 0x60, 0x4E, 0x08, 0x0F, 0x02, 0xF5, 0xB8, 0x70, 0x27, 0x89, 0x29, 0x6E, 0x79, 0x85, + 0x12, 0xA4, 0xCA, 0x6C, 0x69, 0xBE, 0x52, 0xFF, 0xBD, 0xCF, 0x3E, 0x07, 0xA8, 0x7B, 0x00, 0x44, + 0xE0, 0x3B, 0xA6, 0x50, 0xFF, 0xF9, 0xDA, 0x0D, 0xEB, 0xCC, 0x70, 0x21, 0x20, 0x5F, 0xF4, 0xAF, + 0x1B, 0x2C, 0xF8, 0x63, 0x9C, 0xB9, 0x8F, 0x0B, 0xBF, 0x1C, 0xA5, 0x85, 0xA6, 0x9A, 0x0A, 0x93, + 0x1E, 0x8B, 0xA3, 0x80, 0x63, 0x30, 0x24, 0xE1, 0xF0, 0xB6, 0x7B, 0x93, 0xC5, 0x72, 0xE9, 0x49, + 0x91, 0x1D, 0xB0, 0x77, 0xC0, 0xA2, 0x1D, 0xC9, 0x66, 0x90, 0xF7, 0x58, 0x92, 0x87, 0x4F, 0xB0, + 0x0D, 0x0A, 0x48, 0x16, 0x5F, 0x7D, 0xF4, 0xA6, 0xC9, 0x80, 0xD2, 0x38, 0xD6, 0xC7, 0xEE, 0x73, + 0xA6, 0xA8, 0x57, 0xC9, 0xAA, 0x32, 0x6A, 0x3C, 0xA7, 0x9F, 0x89, 0x79, 0x8B, 0xD9, 0x6B, 0x8C, + 0xB1, 0x26, 0x5D, 0x4B, 0xE9, 0xF0, 0x9D, 0xFA, 0xC0, 0xD3, 0xEA, 0x82, 0xDA, 0x7C, 0xCB, 0x43, + 0x90, 0x74, 0x24, 0xC6, 0xBD, 0x5B, 0x87, 0x29, 0xCA, 0xEC, 0x6E, 0xBA, 0x7C, 0x41, 0xF9, 0x99, + 0x0A, 0x92, 0xFA, 0x43, 0xAE, 0xE7, 0xF9, 0xFB, 0x55, 0x5B, 0x3A, 0xCC, 0x1C, 0xC5, 0x20, 0x37, + 0x53, 0x4A, 0x83, 0xC6, 0x79, 0x5A, 0x42, 0xF9, 0x23, 0x62, 0xA1, 0x3A, 0x42, 0xCE, 0x51, 0xC5, + 0x5D, 0xC9, 0x99, 0x1F, 0x82, 0xE7, 0x43, 0x72, 0x46, 0x70, 0x80, 0x25, 0x65, 0x98, 0x78, 0xC2, + 0xF9, 0xD4, 0x07, 0x2D, 0xAB, 0x79, 0x7D, 0x45, 0xC3, 0x0B, 0xEE, 0x18, 0xBB, 0x3C, 0x33, 0xE5, + 0x8B, 0xE5, 0x2A, 0x04, 0x53, 0x7C, 0x92, 0x92, 0x3E, 0x77, 0xE6, 0xB5, 0x8A, 0x7C, 0xAC, 0x3F, + 0xEA, 0xFC, 0x19, 0x64, 0xFD, 0xB4, 0xA3, 0x33, 0xCC, 0xBB, 0xE3, 0x5F, 0xBA, 0xAB, 0x9F, 0x2A, + 0x4E, 0x71, 0x96, 0x4D, 0x8D, 0x33, 0x39, 0x02, 0x0F, 0x6B, 0xFB, 0xC7, 0x76, 0x0D, 0xC4, 0x9D, + 0xB0, 0x6C, 0xA3, 0x91, 0x32, 0x23, 0x60, 0xF9, 0x53, 0x3C, 0x48, 0xCF, 0x54, 0x4A, 0x34, 0x6A, + 0x90, 0xB8, 0xDB, 0xB6, 0xFD, 0xD8, 0xB9, 0x79, 0xF1, 0x5D, 0x64, 0xFC, 0x2C, 0x6E, 0xA2, 0xD2, + 0x4D, 0x37, 0x56, 0xCB, 0x8D, 0xE9, 0xC9, 0x02, 0x3A, 0x7F, 0x53, 0x75, 0x98, 0x46, 0xF9, 0x8E, + 0xE2, 0x00, 0x05, 0x20, 0x8E, 0xAD, 0xAA, 0x38, 0x5F, 0x6A, 0x34, 0x16, 0x2E, 0x25, 0xFF, 0x7F, + 0xE2, 0x10, 0x2D, 0x49, 0x2C, 0xEF, 0xB5, 0xE5, 0x8A, 0x2A, 0x1F, 0x6F, 0x6C, 0x49, 0xF7, 0x78, + 0x80, 0xCA, 0xFA, 0x14, 0x5D, 0xAE, 0xA9, 0xCD, 0xC5, 0xB8, 0xA8, 0xDC, 0xFF, 0x84, 0xC5, 0x80, + 0x8E, 0x98, 0x5F, 0x7E, 0xF6, 0x26, 0xBB, 0x35, 0xF7, 0xA7, 0x40, 0x46, 0x83, 0x26, 0xDF, 0x3B, + 0x64, 0xE0, 0x67, 0x7A, 0xBE, 0x08, 0xF4, 0xE6, 0x1A, 0xF8, 0xFD, 0xBA, 0x0E, 0xBE, 0xB2, 0x28, + 0x6C, 0x45, 0xEA, 0xB1, 0x6C, 0xA8, 0x8E, 0x4F, 0xB8, 0xBC, 0x82, 0x0A, 0xD1, 0x84, 0xAB, 0x03, + 0x6C, 0x30, 0x85, 0xA1, 0x2C, 0x72, 0xA3, 0x08, 0x25, 0x4C, 0x97, 0x32, 0xEB, 0xAD, 0x0E, 0x3E, + 0xE8, 0x8E, 0x2B, 0xF0, 0xCF, 0x13, 0xCA, 0xD1, 0x53, 0xC6, 0xCD, 0x58, 0x98, 0xDE, 0xB0, 0x7E, + 0x0D, 0xBF, 0x94, 0x3E, 0xA7, 0x1C, 0x84, 0xBC, 0xB3, 0x9B, 0x6D, 0x54, 0x32, 0x39, 0x89, 0xF8, + 0x02, 0xAF, 0xBC, 0xB2, 0x53, 0x3B, 0x43, 0xF2, 0xCC, 0xC9, 0x05, 0xF2, 0xC4, 0x88, 0x37, 0x6E, + 0xE1, 0xA1, 0x55, 0x82, 0x7E, 0xBE, 0x83, 0xE0, 0x0B, 0xF8, 0x96, 0x45, 0x61, 0xC1, 0x96, 0x28, + 0x6D, 0x64, 0xCF, 0xF9, 0xC1, 0xC7, 0x3A, 0x18, 0xF3, 0x9A, 0x69, 0x2B, 0x07, 0x57, 0x55, 0xE8, + 0x09, 0xCB, 0x33, 0xC5, 0x4F, 0xBF, 0x0F, 0x9A, 0x22, 0xB1, 0xB3, 0x50, 0x15, 0xA3, 0xCB, 0x8D, + 0x6E, 0x29, 0x56, 0x89, 0x64, 0xAF, 0x5B, 0x0D, 0xD4, 0xE2, 0x6F, 0x6A, 0x38, 0xBD, 0xD8, 0xA1, + 0x7D, 0x0A, 0x6F, 0x7B, 0x07, 0x89, 0x5B, 0xD2, 0xFB, 0x34, 0x5F, 0xA9, 0x0F, 0x41, 0x18, 0xD3, + 0x99, 0xFD, 0xA8, 0x88, 0xFD, 0x4B, 0x9B, 0xCA, 0xAE, 0x5A, 0xB0, 0xEE, 0x23, 0x0F, 0x4B, 0x5C, + 0x99, 0xEA, 0x29, 0xF3, 0xF6, 0x97, 0x5F, 0xF9, 0xAF, 0x28, 0x4F, 0xEC, 0xD6, 0x01, 0x69, 0x8B, + 0x65, 0x08, 0x55, 0xCA, 0x05, 0xC0, 0xB4, 0xB2, 0x64, 0x2A, 0xF5, 0x3E, 0xDA, 0xA2, 0xD2, 0xBB, + 0xDF, 0x17, 0xFF, 0xCF, 0x9E, 0xDE, 0x8A, 0x1E, 0x5F, 0xFD, 0xEA, 0x12, 0x0F, 0xFF, 0x96, 0x20, + 0x0A, 0x15, 0xE6, 0x9B, 0x4F, 0x12, 0x0B, 0xCC, 0x39, 0x4D, 0xFD, 0xD4, 0x7A, 0xDA, 0x24, 0x11, + 0x2D, 0x93, 0x92, 0x9F, 0x3E, 0x3F, 0xA2, 0x9B, 0xAD, 0x98, 0x13, 0xE2, 0x5F, 0xF2, 0x7E, 0x84, + 0xA1, 0x43, 0xAB, 0x76, 0xB8, 0xFC, 0xA0, 0x01, 0x17, 0x38, 0xB3, 0x33, 0x13, 0x4A, 0xF5, 0x15, + 0xA5, 0x56, 0x66, 0xC5, 0x44, 0x0C, 0x88, 0x75, 0x76, 0xA5, 0x7E, 0x57, 0xD4, 0x22, 0xE5, 0x32, + 0x99, 0x60, 0x99, 0x7C, 0x65, 0x29, 0xBA, 0xB0, 0x5B, 0x1F, 0x84, 0x98, 0x0C, 0x06, 0x8A, 0xAE, + 0x96, 0x63, 0x91, 0xB1, 0x75, 0xE6, 0xE6, 0x7A, 0xBF, 0x1E, 0xB5, 0xB6, 0x76, 0x1B, 0xE2, 0xBF, + 0xB4, 0x1F, 0x4D, 0x33, 0xF9, 0x9D, 0x9C, 0x79, 0xE6, 0xF5, 0xA3, 0x8C, 0x72, 0xFE, 0xAE, 0xB1, + 0x13, 0x09, 0x20, 0x91, 0x7C, 0x11, 0x99, 0x68, 0x1A, 0xA7, 0x6B, 0x3F, 0x88, 0xC7, 0xF5, 0x94, + 0x0D, 0xBC, 0x3B, 0xA5, 0x14, 0xD7, 0x8B, 0xA0, 0xA0, 0x70, 0xB4, 0xC2, 0x4E, 0x2F, 0xA8, 0xB1, + 0x0D, 0x7B, 0x8C, 0xD4, 0x96, 0xC1, 0xD1, 0xC5, 0x13, 0x67, 0x24, 0x16, 0x3C, 0xC0, 0xFD, 0x79, + 0x3C, 0x11, 0x69, 0x03, 0xF6, 0x55, 0xF7, 0xF2, 0x09, 0x8B, 0x49, 0x5B, 0xDA, 0x05, 0x3C, 0xDB, + 0x1C, 0x01, 0x1F, 0xDC, 0x4D, 0xE2, 0x09, 0xB6, 0x1F, 0x5F, 0xE2, 0xB0, 0xDF, 0x77, 0xF8, 0x83, + 0x59, 0xCF, 0xEE, 0x8B, 0x14, 0x12, 0xEB, 0xBC, 0x9B, 0xB4, 0x38, 0xFD, 0x38, 0x53, 0xC9, 0xA1, + 0x4E, 0xF6, 0x80, 0xA8, 0xE5, 0x25, 0x89, 0x97, 0xCF, 0x94, 0x06, 0xE4, 0x25, 0xDF, 0x86, 0x46, + 0xA2, 0x54, 0xA7, 0x04, 0xB5, 0xCA, 0x67, 0xF1, 0x95, 0x65, 0x57, 0xE1, 0x38, 0x61, 0xCB, 0x20, + 0xE5, 0x98, 0xF4, 0x07, 0x95, 0x25, 0xBD, 0xBE, 0x9F, 0x87, 0x76, 0x4D, 0x52, 0x96, 0xAE, 0x82, + 0xAE, 0x2C, 0x3C, 0xB6, 0x7C, 0x1A, 0x36, 0xE5, 0x34, 0x13, 0x1B, 0x72, 0x52, 0x8F, 0xFF, 0xE7, + 0x6B, 0x83, 0xDB, 0x88, 0x4A, 0xDB, 0x95, 0x37, 0xFA, 0x9D, 0xA2, 0x49, 0xDB, 0x5A, 0xE3, 0x5C, + 0x95, 0xC7, 0xF8, 0xE0, 0x14, 0x38, 0xB2, 0xCD, 0x09, 0xF4, 0x2A, 0x2A, 0xF7, 0x1A, 0xA1, 0x8E, + 0xB8, 0xBC, 0x3B, 0x51, 0x9A, 0xE4, 0xD1, 0xCF, 0xA7, 0xD1, 0xF9, 0x63, 0x0F, 0x98, 0x3D, 0x61, + 0x51, 0xEC, 0x1B, 0x67, 0x68, 0x88, 0x25, 0x65, 0x0B, 0xA6, 0x32, 0xA2, 0xCD, 0x93, 0xE1, 0x16, + 0x01, 0x12, 0xB2, 0xDA, 0x35, 0xBA, 0x52, 0x66, 0x46, 0x44, 0x8D, 0xB3, 0x19, 0x33, 0xC1, 0x1F, + 0x47, 0x6C, 0x48, 0x7B, 0x5C, 0x8C, 0xA8, 0x68, 0x74, 0xDE, 0x7C, 0xB4, 0xDF, 0x05, 0x54, 0x35, + 0x8A, 0xFE, 0x78, 0xB5, 0x05, 0x78, 0xC3, 0xB4, 0x85, 0x12, 0x88, 0xBB, 0x49, 0x17, 0x46, 0x5D, + 0x7D, 0x1F, 0xF4, 0xB5, 0xD9, 0xEF, 0x62, 0xBA, 0xC4, 0x86, 0x61, 0x0B, 0xE0, 0xC5, 0xEE, 0x69, + 0xEC, 0xF9, 0x52, 0x93, 0x3F, 0xC7, 0x69, 0xE4, 0xD2, 0x9C, 0xE0, 0xEB, 0xB5, 0x5A, 0x55, 0xCE, + 0x87, 0xA3, 0x1C, 0x52, 0x2E, 0xC5, 0x99, 0x92, 0x7F, 0x10, 0x06, 0xC4, 0xA2, 0x5B, 0x77, 0x3D, + 0x53, 0xE8, 0xCA, 0xB5, 0x3B, 0x18, 0x58, 0x54, 0xC6, 0x63, 0xDB, 0x1D, 0xB6, 0x75, 0xD2, 0x69, + 0x64, 0x8A, 0x69, 0x0E, 0xF9, 0x57, 0x41, 0x4C, 0xC2, 0xF3, 0x59, 0x0A, 0x60, 0x76, 0x67, 0x4A, + 0xE6, 0xE8, 0x63, 0xB5, 0x0A, 0x39, 0xDE, 0x95, 0xD6, 0xFB, 0xD4, 0xEC, 0xA3, 0xBD, 0x1A, 0xB1, + 0x8F, 0x54, 0x1C, 0xD7, 0x39, 0x50, 0x8F, 0x92, 0x0D, 0x33, 0x9F, 0x49, 0x10, 0xB2, 0x73, 0x87, + 0x83, 0xF0, 0x72, 0x9D, 0xE7, 0xEA, 0x14, 0xC7, 0x5A, 0x23, 0x6F, 0x54, 0x3E, 0xB5, 0x86, 0x6D, + 0xD6, 0xE2, 0x3E, 0x97, 0x96, 0x5F, 0xF4, 0x1A, 0xFD, 0x8B, 0x96, 0x9B, 0x14, 0xD7, 0x25, 0x3A, + 0x96, 0x25, 0x7B, 0xBE, 0x32, 0x46, 0xC3, 0x20, 0x4E, 0x01, 0x98, 0x0A, 0x27, 0x53, 0x58, 0xFA, + 0xAF, 0x14, 0xE6, 0x6B, 0x99, 0x32, 0x85, 0x87, 0x8F, 0xDA, 0x09, 0x7C, 0x92, 0x9D, 0x4C, 0x87, + 0xF6, 0xB3, 0x67, 0x61, 0xA2, 0x7C, 0x25, 0x5D, 0x4E, 0xA7, 0x6F, 0xF0, 0xCB, 0x6C, 0x6A, 0xC3, + 0xE2, 0x19, 0x33, 0xBE, 0x73, 0x95, 0xE1, 0xBA, 0x39, 0x09, 0x7F, 0xAE, 0x72, 0x8A, 0x4E, 0x74, + 0xA1, 0xBF, 0x5B, 0x1D, 0x34, 0x89, 0xF0, 0x94, 0xE6, 0x84, 0x3C, 0x64, 0x29, 0x04, 0x07, 0x34, + 0xC3, 0x32, 0xEF, 0xF6, 0xE5, 0x24, 0x54, 0x09, 0xFA, 0x81, 0xDB, 0xF1, 0xCF, 0xE5, 0xDB, 0x98, + 0x27, 0xC0, 0xEB, 0xDA, 0x10, 0x73, 0x74, 0x76, 0xCA, 0xD7, 0xFE, 0xDF, 0x82, 0x63, 0x0F, 0x31, + 0x03, 0xBE, 0x10, 0xF4, 0xF6, 0x76, 0xDD, 0x27, 0xAD, 0xE4, 0xC1, 0xFA, 0xC5, 0x5A, 0x71, 0x8D, + 0x59, 0x39, 0x41, 0x6C, 0xDD, 0xFB, 0x4C, 0x5C, 0xB0, 0xB8, 0xF9, 0x67, 0x9C, 0xD7, 0x90, 0x44, + 0xE2, 0xF3, 0x39, 0x4C, 0x84, 0x1A, 0x13, 0x3F, 0xF2, 0xDF, 0x77, 0xA5, 0xF6, 0xAB, 0x69, 0x37, + 0x18, 0x56, 0x03, 0x86, 0xE9, 0xB7, 0xC8, 0xD8, 0x5A, 0xA1, 0x87, 0x00, 0xBC, 0x14, 0x44, 0xFF, + 0x21, 0xDD, 0xAC, 0x99, 0xD2, 0x78, 0xDF, 0x0C, 0xF3, 0xAC, 0x5F, 0xF4, 0x56, 0xE4, 0xAB, 0xCF, + 0x5F, 0x1C, 0x60, 0x7E, 0xFA, 0xDA, 0x36, 0x8A, 0xF2, 0xD4, 0x80, 0x64, 0xC5, 0x54, 0x53, 0xCA, + 0xF3, 0x80, 0x9A, 0x3C, 0x7C, 0x7B, 0x32, 0x30, 0x14, 0xB7, 0x17, 0x9B, 0x42, 0x7C, 0x94, 0x0D, + 0xC4, 0x43, 0x5B, 0xB0, 0x86, 0xE9, 0x1F, 0x80, 0xCD, 0x45, 0x97, 0x3D, 0x8A, 0xD0, 0x22, 0x91, + 0xA0, 0x14, 0xA5, 0xD7, 0x71, 0x07, 0x8D, 0xAB, 0x69, 0xE8, 0x38, 0x98, 0xEE, 0x70, 0x3D, 0x7B, + 0x86, 0x13, 0xDE, 0xAF, 0xE5, 0x89, 0x5A, 0x5F, 0x1F, 0xF9, 0xA5, 0x3F, 0xED, 0x62, 0xE6, 0x65, + 0x3B, 0x86, 0xF9, 0x76, 0xD6, 0x5A, 0x57, 0x54, 0x8B, 0x0D, 0x39, 0xEC, 0x9F, 0x00, 0xBF, 0x4E, + 0xF8, 0x62, 0x51, 0x83, 0x74, 0x16, 0x00, 0x3A, 0x4F, 0x71, 0x18, 0x73, 0xF0, 0x41, 0x71, 0xB4, + 0xDC, 0x79, 0xFC, 0x32, 0xDB, 0x38, 0x0C, 0x3F, 0x1B, 0x66, 0xA4, 0x27, 0xED, 0xA7, 0xE2, 0xE6, + 0xB0, 0x51, 0xF6, 0xBD, 0xEF, 0x2E, 0x0E, 0x10, 0x8F, 0x1D, 0x40, 0xDF, 0x85, 0x67, 0xC7, 0x25, + 0x11, 0x7F, 0x50, 0x99, 0xC8, 0xAE, 0xDF, 0x6A, 0xAF, 0x70, 0x8C, 0xD4, 0xB5, 0x6A, 0xA5, 0x21, + 0x1C, 0xBF, 0x0C, 0x75, 0xA2, 0x40, 0x03, 0x17, 0x58, 0x8C, 0x84, 0x4D, 0x82, 0x29, 0xE5, 0x7C, + 0x05, 0xA1, 0xAF, 0x48, 0x07, 0xD1, 0xF7, 0x53, 0xBC, 0x02, 0xF7, 0xCD, 0x60, 0x35, 0xEE, 0x04, + 0x03, 0xE1, 0x3A, 0xAA, 0x71, 0x54, 0x5B, 0xDD, 0x86, 0x68, 0xFB, 0xC6, 0xBC, 0xCF, 0xCD, 0x55, + 0xBC, 0x0E, 0x0D, 0x8D, 0x7B, 0x70, 0x1F, 0xE4, 0xEC, 0x2C, 0x91, 0x22, 0xF6, 0x55, 0xC9, 0x07, + 0x0F, 0x26, 0x60, 0x4F, 0xB0, 0x27, 0xFA, 0xAB, 0xBF, 0x3B, 0xF1, 0x3F, 0x52, 0xB8, 0xC7, 0x7B, + 0x52, 0xBF, 0x6E, 0xA4, 0x87, 0xCD, 0x40, 0x62, 0x4D, 0xDA, 0xD1, 0x37, 0x77, 0x44, 0xB3, 0x1D, + 0xD6, 0x2F, 0x9A, 0xA8, 0x61, 0x54, 0x6A, 0x1E, 0x2E, 0xE2, 0xC0, 0xBF, 0x7D, 0xAD, 0xB9, 0xDB, + 0x52, 0x5C, 0x0F, 0x15, 0x7F, 0x40, 0x8B, 0xC3, 0x4E, 0xC5, 0xC3, 0x59, 0x5A, 0x19, 0x3F, 0xA1, + 0xB3, 0x58, 0x3A, 0xC2, 0x06, 0x5B, 0x16, 0xF8, 0xEA, 0xFA, 0xB6, 0x8D, 0x93, 0xFF, 0xC4, 0x96, + 0x2C, 0x9F, 0xD0, 0xAB, 0x5A, 0x2B, 0x81, 0x17, 0xA9, 0x71, 0x38, 0x0F, 0x01, 0xEF, 0x5A, 0xC0, + 0xE9, 0x9F, 0x8B, 0x63, 0x47, 0x89, 0x50, 0xC2, 0xFB, 0x8A, 0x8B, 0x9F, 0xEE, 0xC4, 0xC4, 0x7A, + 0xDC, 0xAD, 0xC3, 0x6A, 0x70, 0xA4, 0x71, 0x53, 0xFD, 0xA9, 0x0D, 0xC0, 0x62, 0x23, 0xB8, 0x9D, + 0xAE, 0xA2, 0x12, 0x0B, 0x18, 0x42, 0xB6, 0x93, 0x2A, 0x85, 0x60, 0x09, 0x59, 0x69, 0x52, 0x1F, + 0x1E, 0xBA, 0xBF, 0x0F, 0xA6, 0x8E, 0xB0, 0x8A, 0x03, 0xCA, 0xC5, 0x1C, 0x8E, 0x89, 0xF2, 0x50, + 0xD7, 0x1A, 0xA9, 0x63, 0x83, 0x0F, 0x6D, 0x06, 0x27, 0x1F, 0x40, 0xDA, 0x0B, 0x9E, 0xEB, 0x1F, + 0x7E, 0x4F, 0x8A, 0xF0, 0x38, 0x86, 0x08, 0xC6, 0x3A, 0xFF, 0x29, 0xCC, 0xA7, 0x10, 0x27, 0xF3, + 0x99, 0x3E, 0x52, 0xF3, 0x0F, 0x83, 0x93, 0x9F, 0x63, 0xE8, 0x23, 0x41, 0x71, 0x98, 0x25, 0x1B, + 0xC9, 0x89, 0x15, 0x8F, 0xC8, 0x72, 0x35, 0x72, 0x7D, 0xF2, 0x36, 0x31, 0x64, 0xF5, 0x3A, 0x4C, + 0x15, 0x9B, 0x30, 0x77, 0x36, 0x03, 0xB9, 0xEE, 0xCA, 0x61, 0x22, 0x7C, 0xCF, 0xEE, 0x6C, 0xE4, + 0xEC, 0x83, 0x67, 0x10, 0x07, 0x7A, 0x21, 0x97, 0xDF, 0xC3, 0x2A, 0x27, 0x47, 0xDB, 0x1A, 0x76, + 0x2D, 0xA5, 0x9D, 0xD7, 0x39, 0x54, 0x4F, 0x62, 0x9C, 0xFD, 0x77, 0x0E, 0xB0, 0x4A, 0x0A, 0xD9, + 0x46, 0xC2, 0x28, 0x49, 0xB0, 0x53, 0x99, 0x2A, 0xC2, 0x81, 0xF9, 0x8A, 0xE1, 0x01, 0xDA, 0xCC, + 0x31, 0x60, 0x9B, 0x32, 0x4B, 0x69, 0x2B, 0x89, 0x00, 0xDA, 0xCD, 0x41, 0x0B, 0x13, 0xC0, 0x3C, + 0x4A, 0xD0, 0x32, 0x0A, 0x45, 0x31, 0x54, 0x38, 0x9E, 0x74, 0x56, 0x60, 0x8A, 0xFA, 0x0C, 0x0C, + 0xC8, 0xDC, 0x4E, 0x12, 0x9A, 0xD0, 0x2B, 0xAC, 0xF3, 0x16, 0xD3, 0xE4, 0x5C, 0xA8, 0x3B, 0x8A, + 0x8E, 0x04, 0x4B, 0x09, 0xDE, 0x91, 0x1C, 0xF2, 0x3D, 0xB5, 0x27, 0x23, 0x9A, 0x5F, 0xCA, 0xCE, + 0x1D, 0x81, 0x25, 0xD3, 0x0B, 0x07, 0x3B, 0xA2, 0xED, 0xC1, 0x68, 0xA3, 0x10, 0x1E, 0x49, 0xED, + 0x2B, 0x02, 0xD4, 0x65, 0x6B, 0xDE, 0xF7, 0xE8, 0x3D, 0xC3, 0x41, 0x1E, 0x75, 0xDB, 0xD0, 0xE4, + 0xA7, 0xFF, 0xFC, 0xB3, 0x0D, 0xAE, 0x72, 0x6D, 0xF2, 0x16, 0xF9, 0x4C, 0x9B, 0x2C, 0x83, 0x55, + 0x53, 0x32, 0xB1, 0x4E, 0xE7, 0x7E, 0x7F, 0xF6, 0xBE, 0xE4, 0x7A, 0xF3, 0xDB, 0x73, 0xA5, 0xDC, + 0xB3, 0x1F, 0x1B, 0x9E, 0x93, 0x58, 0x58, 0x4C, 0xDB, 0xED, 0x8C, 0x02, 0xB7, 0x43, 0x10, 0x7F, + 0x32, 0xF0, 0xFC, 0xD2, 0xDA, 0x18, 0xA6, 0x74, 0x80, 0x12, 0x9C, 0xBB, 0xB9, 0xA9, 0x03, 0x76, + 0xC9, 0x4E, 0xE0, 0xE3, 0x63, 0x96, 0xC8, 0x32, 0x04, 0x06, 0x15, 0x52, 0xD1, 0xB6, 0x03, 0x1B, + 0x5D, 0xF2, 0x40, 0x43, 0x37, 0xCF, 0x7C, 0xF5, 0xC4, 0xAB, 0x8B, 0x83, 0x63, 0x5D, 0xE3, 0x3B, + 0x3B, 0x66, 0xE6, 0x19, 0xEF, 0x51, 0x6B, 0x60, 0x6F, 0x3E, 0x71, 0x3D, 0x8E, 0x5A, 0x77, 0xD2, + 0x57, 0x9A, 0x06, 0xE9, 0xBB, 0x8A, 0x50, 0x58, 0x90, 0xF1, 0x17, 0xD7, 0x18, 0x9C, 0x24, 0x65, + 0x3D, 0x40, 0xA5, 0xA1, 0xD8, 0x24, 0x4B, 0xAA, 0x8A, 0x47, 0x3F, 0x0D, 0xB6, 0x60, 0xE6, 0x75, + 0xCD, 0x45, 0x6D, 0x54, 0xD9, 0x67, 0x65, 0xE0, 0x04, 0xCC, 0xBE, 0xCC, 0xAA, 0x8E, 0x3D, 0xB9, + 0x1E, 0x03, 0x25, 0x25, 0x31, 0x88, 0x36, 0xF6, 0x52, 0xD7, 0x4E, 0x75, 0xB5, 0xEA, 0x05, 0x83, + 0x59, 0xAD, 0xAF, 0xF4, 0x13, 0xCE, 0x5D, 0xF4, 0x52, 0x98, 0xBC, 0x63, 0xFE, 0xB0, 0xC5, 0x55, + 0xBD, 0x5A, 0x65, 0x3E, 0xAF, 0x24, 0x4C, 0x5E, 0xEA, 0x9A, 0x44, 0x32, 0x0E, 0x39, 0xCA, 0x60, + 0xB2, 0xBF, 0x62, 0x40, 0x19, 0x57, 0xDE, 0x7C, 0x70, 0xD7, 0xC3, 0x0E, 0x9A, 0x98, 0x6F, 0x26, + 0x22, 0x45, 0xC4, 0xD1, 0x8E, 0x6B, 0xC9, 0x3F, 0x1E, 0x71, 0x4F, 0x2E, 0x86, 0x42, 0x73, 0x00, + 0xEB, 0x98, 0x22, 0x03, 0x1F, 0x6F, 0xC3, 0xAF, 0xD0, 0x55, 0x8F, 0x95, 0x6F, 0x8E, 0x4B, 0xF0, + 0x21, 0x1D, 0xA7, 0xB1, 0xE8, 0x6B, 0xC7, 0x8A, 0xAD, 0x69, 0xD7, 0x6A, 0x7F, 0x09, 0x3A, 0x9F, + 0xBF, 0x30, 0x27, 0x18, 0x00, 0x11, 0xF2, 0x96, 0xAB, 0x57, 0xD3, 0x67, 0x5D, 0x2A, 0x36, 0xCF, + 0xE2, 0x05, 0xBB, 0x01, 0x83, 0x0B, 0xC7, 0x6D, 0xE9, 0xFD, 0x5A, 0xC8, 0x0D, 0x9C, 0xC0, 0xA2, + 0x41, 0x8D, 0x0E, 0x53, 0xB2, 0xD2, 0x2B, 0xD8, 0xE5, 0x4C, 0xEE, 0x81, 0x52, 0xED, 0xE8, 0xEA, + 0xF1, 0xF3, 0x2A, 0x5D, 0xEC, 0x2D, 0x0E, 0xFD, 0x76, 0x26, 0x4C, 0x25, 0x78, 0x26, 0x6F, 0x2F, + 0xF7, 0x31, 0xAB, 0xC0, 0x6C, 0x80, 0x1F, 0x2B, 0x8B, 0x1E, 0xC1, 0x09, 0x46, 0x5E, 0x94, 0x19, + 0xED, 0x07, 0x94, 0xEC, 0xCF, 0x3B, 0xC6, 0x51, 0x29, 0xC2, 0x87, 0xD4, 0x55, 0xD0, 0xAD, 0x82, + 0x66, 0x27, 0x61, 0x18, 0xDD, 0xB8, 0xBD, 0xF9, 0xE1, 0xCA, 0xAA, 0xBA, 0x49, 0x39, 0xD6, 0x43, + 0xA9, 0x10, 0x12, 0x7C, 0xA6, 0x82, 0xD8, 0xDB, 0x11, 0x76, 0x9D, 0xF0, 0x92, 0xFB, 0x31, 0xC1, + 0x9C, 0x31, 0x78, 0x1C, 0x11, 0xD6, 0xF3, 0x1F, 0x14, 0x39, 0xC6, 0x33, 0x46, 0x58, 0x8C, 0xE9, + 0x2B, 0x87, 0x94, 0xA6, 0xFA, 0x55, 0x5A, 0x3C, 0x39, 0x60, 0xD0, 0x26, 0x0F, 0xB3, 0x56, 0x18, + 0x77, 0x9C, 0x1B, 0x01, 0xBA, 0xE6, 0xB2, 0x1E, 0x8B, 0xA0, 0x63, 0x2D, 0x7E, 0xA2, 0x30, 0xFC, + 0xDF, 0x31, 0x99, 0xB2, 0xD6, 0x1E, 0xD3, 0xAB, 0xB7, 0xFA, 0x72, 0xB0, 0x6F, 0xE5, 0x6B, 0x9F, + 0xAF, 0xB4, 0xF0, 0x53, 0x06, 0x9C, 0xB0, 0x98, 0x6B, 0xF4, 0x5A, 0x52, 0xDB, 0xD0, 0x13, 0xED, + 0x73, 0x70, 0x11, 0xBB, 0xD0, 0x98, 0x58, 0xCA, 0x29, 0x44, 0xCB, 0x7C, 0x2D, 0x43, 0xDE, 0x4F, + 0xBF, 0x13, 0x06, 0xDD, 0x3C, 0x69, 0x49, 0xD2, 0xD7, 0xA7, 0x24, 0x9E, 0x0D, 0x3C, 0x8C, 0x73, + 0x0F, 0xB2, 0x4F, 0x16, 0x83, 0x7E, 0x7B, 0x3A, 0xD4, 0x49, 0x42, 0x26, 0x9C, 0x6F, 0xAF, 0xD6, + 0x73, 0xEF, 0x29, 0x3D, 0x1A, 0x21, 0x58, 0x48, 0xF7, 0xEE, 0xD2, 0xC8, 0x06, 0x4D, 0xB2, 0x3D, + 0x1E, 0xD6, 0xF6, 0xF3, 0x25, 0xC8, 0xD5, 0xF4, 0xB6, 0x07, 0x2C, 0xB0, 0x03, 0xDE, 0x83, 0xE0, + 0x1C, 0x68, 0x2E, 0x78, 0xB6, 0xDA, 0x99, 0xA6, 0xBD, 0xE8, 0x1D, 0x47, 0x6E, 0x7A, 0x4C, 0xC5, + 0xE4, 0x54, 0xEA, 0xDB, 0xB1, 0x6F, 0x9F, 0x53, 0xA6, 0x41, 0xE2, 0x24, 0x6C, 0x9C, 0x88, 0xF7, + 0x88, 0xA8, 0x90, 0x0D, 0x34, 0x61, 0xAA, 0x7D, 0x52, 0x5F, 0x8D, 0x81, 0xBE, 0xC9, 0x3E, 0x36, + 0x8D, 0x69, 0x81, 0x0D, 0x24, 0x7D, 0xCE, 0x03, 0xB8, 0x4E, 0x9C, 0xFD, 0x5A, 0x4A, 0x45, 0xAF, + 0x45, 0xB5, 0xFF, 0x49, 0xEA, 0x6C, 0xF7, 0xB9, 0xE5, 0xC1, 0xA6, 0x57, 0xF3, 0xCA, 0xCC, 0x46, + 0xD2, 0x20, 0xB3, 0xB1, 0xC0, 0x18, 0xEE, 0x82, 0xE4, 0x00, 0x3C, 0xA7, 0x8B, 0xA6, 0x3A, 0xDA, + 0x82, 0x53, 0x3C, 0x42, 0x4C, 0x3B, 0x16, 0xD0, 0x3E, 0x0E, 0xBA, 0x36, 0xA6, 0xEA, 0x36, 0x16, + 0x80, 0xA3, 0x51, 0xFD, 0xF8, 0xFA, 0xE5, 0x75, 0x64, 0x17, 0x0C, 0xE5, 0xAE, 0xB2, 0xE5, 0x14, + 0xC1, 0xA9, 0xAE, 0x3A, 0x7E, 0x4D, 0x0E, 0x5C, 0x67, 0x31, 0x02, 0xD2, 0x4D, 0xB3, 0xD6, 0xC6, + 0xE6, 0x86, 0xC2, 0x62, 0xE6, 0xB6, 0x53, 0x2C, 0x29, 0x72, 0x90, 0x55, 0xAC, 0x1C, 0xE7, 0x7F, + 0x7F, 0xA3, 0xE8, 0x21, 0xF0, 0x2D, 0x3E, 0x8A, 0xA3, 0xA2, 0xA2, 0x29, 0xEC, 0x36, 0x4B, 0x89, + 0x1C, 0xB6, 0xC1, 0xB9, 0x4A, 0x8F, 0x65, 0xDF, 0x97, 0x29, 0x0F, 0x0B, 0xB1, 0x61, 0x24, 0xA2, + 0xD2, 0x57, 0x7A, 0x99, 0xF7, 0x1D, 0xC8, 0xB4, 0xDD, 0xEE, 0x7A, 0xBE, 0x2E, 0x46, 0x9A, 0xF6, + 0x92, 0x13, 0xAC, 0x98, 0x64, 0x4C, 0xDD, 0x6B, 0x03, 0xD3, 0xF4, 0x14, 0xC9, 0x7D, 0xCE, 0x9B, + 0xF7, 0xD4, 0x80, 0xB1, 0x2A, 0x66, 0x33, 0xA4, 0xE2, 0x45, 0x99, 0x95, 0x77, 0xE1, 0x3E, 0x8A, + 0x43, 0x85, 0xD9, 0x79, 0x69, 0x0D, 0x55, 0xCF, 0x09, 0xF4, 0xFC, 0x07, 0x39, 0x20, 0x26, 0xB4, + 0x8B, 0xD0, 0x60, 0xFB, 0x42, 0x41, 0xEF, 0x02, 0x5F, 0x0D, 0xC7, 0x7F, 0x09, 0xFA, 0x26, 0x94, + 0x7A, 0xCD, 0xDE, 0x43, 0x86, 0x44, 0xD6, 0xC6, 0xB1, 0x77, 0x13, 0xB1, 0x08, 0xC9, 0xDD, 0x99, + 0xF0, 0xED, 0x7B, 0xB0, 0xAB, 0x31, 0x6D, 0x5B, 0x66, 0xA3, 0x53, 0xE2, 0x3B, 0x0F, 0x31, 0xA2, + 0x63, 0x6E, 0x05, 0xAD, 0xC6, 0x74, 0xC5, 0x2D, 0xB3, 0x79, 0xEB, 0x66, 0xF3, 0x6B, 0x79, 0x02, + 0x7A, 0x7D, 0x49, 0x59, 0x30, 0x04, 0x29, 0xD8, 0x5E, 0xF7, 0xF3, 0x6C, 0x5E, 0xC2, 0xA6, 0xFF, + 0x1B, 0x5A, 0xFE, 0x01, 0x54, 0x40, 0xEF, 0xA0, 0xD5, 0xDB, 0x47, 0xED, 0x2A, 0x9B, 0x85, 0x12, + 0x9F, 0x74, 0x5D, 0xB7, 0xA6, 0x80, 0x22, 0x34, 0x87, 0x81, 0x7E, 0x15, 0x87, 0x62, 0x03, 0x87, + 0x62, 0x6B, 0x85, 0xF1, 0x37, 0x55, 0x55, 0x31, 0x18, 0xBD, 0xEF, 0x57, 0x1D, 0x21, 0x5E, 0x87, + 0x37, 0x53, 0x61, 0x7B, 0xA5, 0x80, 0x71, 0x2C, 0x72, 0x83, 0x64, 0x73, 0xF2, 0x4C, 0xA0, 0x3F, + 0x4C, 0x3E, 0x21, 0xF3, 0x96, 0xBB, 0x9C, 0x05, 0xE1, 0x12, 0x47, 0xA2, 0x6E, 0xF6, 0x67, 0xFE, + 0x1B, 0x3F, 0x74, 0xA5, 0x6B, 0x2E, 0xB3, 0x77, 0x02, 0x64, 0x30, 0xAF, 0x6C, 0x64, 0x2E, 0x69, + 0x92, 0xA5, 0xD3, 0xA8, 0xEE, 0xEF, 0xB7, 0x89, 0xD9, 0x31, 0x1B, 0x61, 0xC8, 0x91, 0xF1, 0xC5, + 0x59, 0x7D, 0xCE, 0xDF, 0xFB, 0xF2, 0x10, 0xF7, 0x42, 0x02, 0xEC, 0x70, 0x2F, 0xE4, 0x02, 0xB4, + 0xFB, 0xA0, 0xFC, 0x83, 0x58, 0x68, 0xA2, 0x8E, 0x01, 0x8B, 0x10, 0xF6, 0x30, 0x86, 0xAA, 0x5A, + 0xC4, 0x95, 0x61, 0x02, 0x8E, 0xF2, 0xB7, 0x6B, 0x6C, 0x80, 0x5C, 0xCB, 0x11, 0x66, 0x97, 0x60, + 0x70, 0xD4, 0x06, 0xA9, 0xC7, 0x80, 0xE3, 0x2C, 0xA4, 0xE1, 0xAA, 0x34, 0x92, 0x13, 0x57, 0x05, + 0xF9, 0x70, 0xF3, 0xF4, 0x80, 0x73, 0xF2, 0x16, 0xDA, 0xBD, 0x39, 0x51, 0xD1, 0x40, 0xC1, 0x59, + 0x04, 0xCD, 0xE4, 0x79, 0x63, 0x24, 0x69, 0xC6, 0x99, 0x2F, 0x4D, 0x0D, 0x1C, 0x9C, 0x15, 0xED, + 0x41, 0x47, 0x12, 0x78, 0x6F, 0x8E, 0xFF, 0xA7, 0x34, 0xB8, 0x8B, 0x0C, 0x70, 0x96, 0x07, 0x0B, + 0x49, 0x42, 0x59, 0xFE, 0x5A, 0x08, 0x76, 0x36, 0x3D, 0x7D, 0xBA, 0x10, 0x1B, 0x11, 0xB4, 0x6B, + 0x1C, 0x59, 0x60, 0x02, 0x36, 0x30, 0xD9, 0xEC, 0xBA, 0xEE, 0x22, 0xFD, 0x0F, 0x2E, 0xA2, 0xE2, + 0x70, 0x9C, 0x0D, 0x18, 0x58, 0x88, 0x4A, 0x0D, 0xE7, 0x0E, 0xEF, 0xD8, 0x6F, 0xA7, 0x70, 0x12, + 0x9D, 0x06, 0x4C, 0x8C, 0xAD, 0x1A, 0x28, 0x01, 0xB6, 0x23, 0x53, 0x76, 0xDD, 0x3F, 0x17, 0x87, + 0x0B, 0xC1, 0xEB, 0x9C, 0x44, 0x67, 0x1B, 0x79, 0xE0, 0x67, 0xB2, 0x2A, 0x99, 0x72, 0xEB, 0x4C, + 0xB4, 0x17, 0x2E, 0xB5, 0xE8, 0x52, 0x1E, 0xCB, 0x3A, 0x3D, 0xF7, 0xF2, 0x21, 0xC7, 0xF1, 0x29, + 0x97, 0x22, 0x31, 0x2C, 0x39, 0x8A, 0xAF, 0x47, 0xF9, 0x3B, 0xA9, 0x8B, 0x2B, 0xEF, 0xE2, 0xF0, + 0x11, 0x59, 0xFC, 0xE4, 0x56, 0xFF, 0x4E, 0xA7, 0x92, 0xE5, 0xE5, 0x26, 0x16, 0xC8, 0x2C, 0x35, + 0xD2, 0x70, 0x9F, 0xAE, 0xA7, 0x08, 0x16, 0x2B, 0x64, 0xA1, 0xF6, 0xF3, 0xC1, 0x43, 0x27, 0x92, + 0x46, 0x4E, 0xA2, 0x01, 0x72, 0x18, 0x08, 0xAB, 0x22, 0x42, 0x1B, 0x9E, 0x35, 0xAE, 0xB3, 0xE6, + 0x42, 0x1B, 0x49, 0x31, 0xBB, 0xA4, 0xD0, 0xD6, 0x7A, 0xEB, 0xFE, 0x32, 0x37, 0x7F, 0xE6, 0x2F, + 0x75, 0x54, 0x1D, 0x88, 0x9F, 0x81, 0xEE, 0xF0, 0x97, 0xC9, 0x12, 0x80, 0x47, 0x5C, 0xCA, 0x3B, + 0x45, 0xF4, 0x63, 0xC3, 0x16, 0x2D, 0x7E, 0xCD, 0x80, 0xC2, 0xBA, 0x50, 0x1D, 0xC2, 0x31, 0x72, + 0xF0, 0x27, 0x97, 0xB0, 0xF4, 0x69, 0x43, 0x2B, 0x26, 0x89, 0x28, 0xFC, 0xBD, 0x03, 0x6A, 0x4A, + 0x22, 0x5D, 0xD3, 0x7D, 0xEC, 0xC8, 0xEC, 0x7B, 0x15, 0xFA, 0x05, 0x5D, 0x73, 0x6B, 0x5B, 0x1B, + 0xC9, 0x83, 0xD0, 0xFA, 0x24, 0xBA, 0x97, 0x11, 0x30, 0x04, 0xD3, 0x11, 0xCE, 0x24, 0xBD, 0x71, + 0xB7, 0xAA, 0xB2, 0xC2, 0x43, 0xC2, 0x67, 0x3B, 0x9C, 0x28, 0x62, 0x52, 0xF0, 0xFA, 0xCB, 0xFA, + 0xDF, 0x4F, 0xC9, 0x23, 0xD1, 0x94, 0xE1, 0x5F, 0x2A, 0xF2, 0xC7, 0x5F, 0x76, 0x6B, 0x86, 0x28, + 0x29, 0xF1, 0x54, 0x4F, 0x7A, 0x4D, 0xFD, 0xD0, 0x51, 0xFA, 0xBC, 0x6F, 0x7B, 0x44, 0xE5, 0xB0, + 0xF3, 0xC0, 0x34, 0x80, 0x6D, 0xE6, 0xDD, 0xCD, 0x7F, 0x67, 0x7B, 0x15, 0xC5, 0xE5, 0x14, 0x64, + 0x80, 0x81, 0xD9, 0x47, 0xCE, 0x71, 0x62, 0x94, 0xCE, 0x41, 0x61, 0xFA, 0xDD, 0x5A, 0x6D, 0xC1, + 0x28, 0x87, 0x39, 0xC4, 0xBC, 0x89, 0x3A, 0x99, 0x18, 0x80, 0xDC, 0x50, 0x72, 0xCF, 0x67, 0x4D, + 0x77, 0x6D, 0x6A, 0xB4, 0x17, 0x85, 0xD6, 0x2B, 0xC3, 0x4A, 0x7C, 0xD1, 0xF3, 0x0E, 0xA4, 0x8F, + 0x3B, 0xDA, 0x8A, 0x7B, 0x0A, 0x37, 0x7D, 0x36, 0xEC, 0x89, 0x87, 0xD9, 0x88, 0xB7, 0xC9, 0x1F, + 0xEB, 0xEE, 0x25, 0x46, 0xA9, 0x3B, 0x19, 0x16, 0x17, 0x2D, 0x0F, 0x8C, 0xEB, 0x19, 0xF3, 0x47, + 0xC7, 0x21, 0xA8, 0x1E, 0x7F, 0xC4, 0xE3, 0x6B, 0x96, 0x1D, 0x63, 0xDD, 0xC2, 0xEF, 0xB2, 0x65, + 0x60, 0x07, 0xE5, 0xD3, 0x48, 0x49, 0x9A, 0xF2, 0xB0, 0x76, 0x2D, 0xFB, 0x68, 0xF8, 0xAD, 0xE9, + 0x3C, 0x52, 0x37, 0x9A, 0xD1, 0xAE, 0x16, 0x37, 0x2E, 0xB3, 0x63, 0xE0, 0x66, 0xB1, 0x4D, 0x49, + 0x83, 0xD2, 0xEA, 0x20, 0xFD, 0x43, 0x84, 0x5B, 0x22, 0xBC, 0x0C, 0xA1, 0x85, 0x28, 0xF7, 0x45, + 0xF1, 0x2A, 0xC2, 0xFE, 0x87, 0x4C, 0xFC, 0x0A, 0x5B, 0xD9, 0x84, 0x7A, 0xAC, 0x8C, 0xBD, 0xDF, + 0xDC, 0xA5, 0xFC, 0xD0, 0x85, 0x65, 0xA2, 0x73, 0x1C, 0x7C, 0xFD, 0xF9, 0xBA, 0x1E, 0xBD, 0x5F, + 0x06, 0xE8, 0xFC, 0x62, 0xD1, 0xF7, 0x13, 0x52, 0xE3, 0xC2, 0xEB, 0xEE, 0x0E, 0x7E, 0x9D, 0x8A, + 0x19, 0x3E, 0xA2, 0x62, 0x06, 0xC5, 0xA1, 0xDC, 0x6B, 0x4A, 0x59, 0xA6, 0x57, 0x73, 0xCB, 0x57, + 0x16, 0x99, 0xFB, 0x93, 0x36, 0xDF, 0x0E, 0x1A, 0x38, 0xD4, 0x89, 0x02, 0x79, 0xB6, 0xA8, 0x52, + 0xCB, 0x2E, 0x96, 0xD4, 0xD8, 0x52, 0xA9, 0x7C, 0xE3, 0x97, 0x47, 0x6F, 0x6E, 0x82, 0x6D, 0x3A, + 0x01, 0x8F, 0x2F, 0x59, 0xDF, 0x93, 0xBA, 0x52, 0xC4, 0x46, 0xDA, 0xC5, 0x0C, 0x2E, 0x40, 0xB8, + 0x37, 0x55, 0x40, 0xB8, 0x13, 0xCD, 0x51, 0x96, 0xCE, 0x4A, 0x6C, 0x0D, 0xF9, 0x5A, 0xE6, 0x34, + 0x95, 0xF0, 0xFF, 0x54, 0x93, 0x05, 0x9D, 0x56, 0x94, 0xF7, 0x23, 0x90, 0x00, 0x44, 0xA7, 0xD9, + 0x86, 0x71, 0xB2, 0xFD, 0x58, 0x19, 0xBB, 0xEC, 0x6B, 0x90, 0x07, 0x2B, 0x7A, 0x20, 0x4B, 0xFD, + 0x0E, 0xB8, 0xF8, 0x00, 0x13, 0xC2, 0xF2, 0x32, 0x39, 0xED, 0x71, 0x59, 0x71, 0xC4, 0xDC, 0xE5, + 0xC2, 0xA9, 0x2B, 0x7B, 0x52, 0x00, 0xCB, 0x49, 0xB4, 0x00, 0xE6, 0x98, 0x13, 0xC1, 0x2F, 0x3A, + 0x19, 0x86, 0xD5, 0x74, 0xCD, 0xBC, 0xBA, 0x4C, 0x48, 0x00, 0x8E, 0x22, 0xD5, 0xAC, 0x11, 0xEF, + 0xC8, 0xCD, 0x99, 0xBA, 0xBC, 0x0F, 0xD4, 0xC0, 0xAE, 0x15, 0x2F, 0x82, 0x6D, 0x4D, 0x44, 0x10, + 0xF1, 0xF5, 0x55, 0xF0, 0x00, 0xAF, 0xEA, 0x96, 0x1F, 0xE6, 0xA6, 0x9A, 0x78, 0xDD, 0x6D, 0xD5, + 0xDF, 0xA4, 0x4D, 0xAE, 0x05, 0xEE, 0x12, 0x9F, 0x9B, 0x99, 0xAC, 0xE4, 0xBE, 0x9E, 0x56, 0xCC, + 0x4B, 0x6D, 0x26, 0xB9, 0x56, 0x9B, 0x9B, 0x52, 0x6D, 0x14, 0x28, 0x7D, 0xE8, 0x75, 0xCB, 0x59, + 0xC0, 0x50, 0x69, 0x6B, 0xD7, 0x68, 0x06, 0xA8, 0x38, 0xD1, 0xBB, 0xD9, 0xA3, 0x3D, 0xA1, 0xBD, + 0x7D, 0x9E, 0xD2, 0xB9, 0x5D, 0x35, 0x02, 0xE0, 0xD4, 0xAF, 0x66, 0x56, 0x7D, 0xF4, 0x88, 0x74, + 0x3C, 0x28, 0x2C, 0xBA, 0x20, 0xC1, 0x2A, 0x93, 0xA9, 0xBA, 0x90, 0xE8, 0xC2, 0xE9, 0x15, 0xC8, + 0x8F, 0xBD, 0x27, 0xDE, 0x21, 0xBF, 0x56, 0x69, 0x93, 0x72, 0x7E, 0xE4, 0xE7, 0x7D, 0xE8, 0x4D, + 0xBF, 0x24, 0xA2, 0x77, 0xC0, 0xE0, 0x30, 0xD9, 0xEE, 0x82, 0xCD, 0x21, 0x60, 0xFC, 0xD1, 0x6F, + 0xB4, 0x40, 0x01, 0xFE, 0xF4, 0x73, 0xAF, 0xBB, 0xF6, 0x2B, 0x41, 0xFC, 0xDE, 0x74, 0x78, 0xE5, + 0x7E, 0xAB, 0xC9, 0xED, 0x63, 0x4B, 0x3E, 0x1A, 0x27, 0xCD, 0xBF, 0x85, 0xA4, 0x70, 0x92, 0x36, + 0x56, 0x70, 0x4A, 0xEE, 0x45, 0xAB, 0x33, 0x0A, 0x76, 0xB8, 0x0B, 0xEA, 0x55, 0xC7, 0x4E, 0xD7, + 0xD9, 0xC7, 0x10, 0x8D, 0x09, 0xFA, 0x10, 0x30, 0x62, 0x20, 0xE5, 0xBC, 0xFB, 0x74, 0x72, 0xA6, + 0x77, 0xB5, 0xBB, 0xD7, 0xD6, 0x60, 0x3A, 0x6B, 0x5D, 0xF5, 0x35, 0xF4, 0x84, 0xA0, 0x19, 0x49, + 0x36, 0x00, 0xC9, 0x35, 0xCC, 0xF7, 0xFE, 0x92, 0xF9, 0x4B, 0x8B, 0xB3, 0xBE, 0x98, 0xBF, 0xF4, + 0x25, 0xB1, 0x62, 0x4D, 0x41, 0xA0, 0xF7, 0x36, 0x6C, 0x86, 0x3C, 0x4F, 0xC4, 0xF8, 0xF2, 0xFC, + 0xE6, 0x34, 0x30, 0x95, 0x32, 0x9D, 0xE5, 0x85, 0x70, 0xD8, 0xB8, 0xD6, 0xD9, 0x42, 0xB9, 0x05, + 0x6E, 0x4B, 0x6F, 0x29, 0x33, 0x8E, 0xE4, 0x31, 0x3C, 0x21, 0x7B, 0x19, 0x31, 0x97, 0xD5, 0x62, + 0x6B, 0xF6, 0x98, 0x3C, 0xA5, 0x54, 0x18, 0x16, 0x03, 0x49, 0x51, 0x1F, 0x13, 0x37, 0xFB, 0x18, + 0x9D, 0xCF, 0x16, 0x43, 0x34, 0x7D, 0xB6, 0x5C, 0x9E, 0x74, 0x4D, 0x66, 0x23, 0x99, 0xDE, 0x6E, + 0x57, 0xFE, 0x47, 0x0D, 0x3B, 0x59, 0x3F, 0x01, 0x79, 0x75, 0x0D, 0x78, 0x62, 0x4A, 0xA5, 0xF2, + 0xF8, 0xD6, 0xAE, 0x11, 0x85, 0x88, 0x13, 0x98, 0x07, 0x0B, 0x92, 0x99, 0xC6, 0x9F, 0x85, 0x24, + 0xB1, 0x48, 0xEF, 0x59, 0x11, 0xCB, 0xAB, 0x92, 0xE4, 0x58, 0x50, 0xAA, 0xE8, 0x97, 0xD5, 0xCD, + 0x63, 0x57, 0x61, 0x62, 0x06, 0xBD, 0x26, 0x08, 0x0E, 0xC6, 0x42, 0x98, 0x8E, 0x82, 0x13, 0xD7, + 0xB8, 0x18, 0x7B, 0xAA, 0xFD, 0x42, 0x51, 0x07, 0xDE, 0x6F, 0xCF, 0xE7, 0x87, 0xF6, 0xBF, 0x15, + 0x8D, 0x8E, 0xFD, 0xA9, 0x4A, 0x45, 0x81, 0x57, 0x8F, 0x22, 0x4D, 0x63, 0x21, 0x4E, 0x41, 0x3C, + 0xCD, 0x77, 0xF5, 0xEC, 0xB8, 0x15, 0x8A, 0xBC, 0x69, 0x22, 0x98, 0xE5, 0xA4, 0x66, 0x47, 0xC5, + 0x9F, 0xE9, 0x9D, 0x06, 0xD8, 0xD2, 0x37, 0xA0, 0x4C, 0xDC, 0x33, 0xD4, 0xE7, 0xED, 0x77, 0x7D, + 0xA2, 0x20, 0x81, 0xB2, 0x46, 0xC5, 0xF6, 0xF5, 0x2A, 0x76, 0x50, 0xAF, 0xC2, 0x5A, 0xC7, 0x8F, + 0xD8, 0x3C, 0x4F, 0x2F, 0xE3, 0x56, 0x04, 0xB2, 0x6C, 0x8C, 0x0D, 0x84, 0xD7, 0xE0, 0xB5, 0x45, + 0xB2, 0x93, 0x34, 0xA0, 0xC2, 0xF4, 0x3A, 0x28, 0xDC, 0x50, 0xE8, 0xF3, 0xF0, 0x7C, 0x67, 0x1A, + 0x11, 0xD7, 0x8D, 0xB2, 0x71, 0x3D, 0xB3, 0x68, 0x49, 0x19, 0x29, 0x54, 0xDF, 0x44, 0xB9, 0x48, + 0xDD, 0x9E, 0xCE, 0xCD, 0x2D, 0x69, 0xB6, 0x18, 0xAD, 0xBC, 0xDC, 0xDF, 0x1F, 0x48, 0x04, 0x16, + 0xD6, 0x3A, 0x39, 0x7E, 0x30, 0xDB, 0x9D, 0xE1, 0x14, 0xF2, 0x5F, 0xDB, 0x1D, 0xBB, 0x7F, 0x4F, + 0x49, 0xBF, 0x4D, 0x2B, 0x9B, 0x5C, 0x7E, 0xA8, 0x1B, 0x79, 0x4F, 0x29, 0xA2, 0xF8, 0xBA, 0x36, + 0x86, 0x10, 0xFA, 0x7C, 0x45, 0x99, 0xE9, 0xD1, 0xDB, 0x93, 0xDB, 0x2A, 0xD5, 0xA8, 0x61, 0x48, + 0xBA, 0xD9, 0x40, 0xD7, 0xAE, 0xE5, 0x35, 0xAA, 0xF0, 0xA5, 0xFD, 0xC5, 0x64, 0x0B, 0x31, 0xA5, + 0x9D, 0x83, 0x31, 0xF6, 0xB8, 0xB5, 0x18, 0x3E, 0xB4, 0x2A, 0x8E, 0x70, 0x7A, 0xB8, 0xAC, 0xB5, + 0x92, 0xDD, 0x12, 0xA7, 0x9D, 0x41, 0xB1, 0x16, 0xE8, 0x45, 0x63, 0x1B, 0xB9, 0x73, 0xF1, 0x19, + 0xF6, 0xAE, 0x0F, 0xF3, 0xF7, 0x60, 0xED, 0x27, 0x70, 0x12, 0x8C, 0x12, 0x3A, 0xCF, 0xA6, 0xDC, + 0xBD, 0x17, 0x82, 0x05, 0x6E, 0x10, 0x04, 0xD4, 0xE7, 0x10, 0x9B, 0x83, 0x55, 0xB0, 0xED, 0x1B, + 0xF9, 0x7D, 0x75, 0x8E, 0xB2, 0x26, 0xA7, 0xBD, 0xE2, 0x0F, 0x29, 0x25, 0x6C, 0xFD, 0xC9, 0xC4, + 0x72, 0xE1, 0x1C, 0xDC, 0x9E, 0xBE, 0x69, 0xB5, 0xE8, 0x31, 0x83, 0x03, 0x5A, 0xEA, 0xA3, 0x52, + 0xD7, 0x51, 0x8A, 0x76, 0xB8, 0x83, 0xF0, 0x5E, 0xDC, 0xFC, 0xED, 0x80, 0x36, 0x7A, 0x39, 0xC6, + 0xFC, 0xF3, 0xC3, 0xE1, 0x5D, 0x15, 0x05, 0x30, 0xF6, 0x74, 0x93, 0x45, 0xB5, 0x2B, 0x0B, 0x63, + 0x2E, 0xF1, 0x24, 0x4B, 0x16, 0xD9, 0x61, 0xDB, 0x97, 0x9A, 0xC8, 0xFF, 0xCE, 0x74, 0xE9, 0x39, + 0x93, 0x00, 0xF8, 0xE0, 0x50, 0x62, 0x07, 0x0A, 0x6B, 0xB4, 0xBA, 0x2B, 0x61, 0x09, 0x25, 0x58, + 0x18, 0x0A, 0xB8, 0xDA, 0x8D, 0xFA, 0x8C, 0x4A, 0x41, 0xBE, 0xA4, 0x51, 0x9B, 0x83, 0x14, 0xC4, + 0xB5, 0x81, 0xB0, 0xA1, 0x35, 0x48, 0x34, 0xEB, 0xAF, 0x74, 0xF4, 0x61, 0xC5, 0x00, 0x39, 0x7D, + 0xAD, 0xF1, 0x07, 0x9C, 0x43, 0x20, 0x8F, 0x4B, 0x3D, 0xD3, 0x7C, 0x91, 0x1D, 0xC3, 0x3B, 0x06, + 0x50, 0x59, 0xA9, 0xC9, 0xA3, 0x23, 0xC9, 0xA6, 0x8A, 0x29, 0x84, 0x0D, 0x7D, 0xEE, 0x56, 0x5D, + 0xA1, 0xB6, 0xA3, 0xE7, 0x1F, 0x2A, 0xFB, 0x95, 0x7B, 0xFC, 0x9F, 0x9A, 0x18, 0xEA, 0xFF, 0xFD, + 0x61, 0x75, 0x3A, 0xF2, 0x22, 0xFF, 0xEB, 0xA2, 0x7C, 0x5A, 0x16, 0xB1, 0xE9, 0x93, 0xB0, 0x4D, + 0xA7, 0xA4, 0xB0, 0xAF, 0x70, 0x8C, 0x7E, 0x7D, 0xE8, 0x4F, 0xAA, 0x9D, 0x81, 0xD6, 0xF8, 0xB5, + 0xB6, 0x32, 0xA5, 0x31, 0xA1, 0x55, 0x11, 0x3A, 0x01, 0x13, 0x38, 0x3A, 0x41, 0x7A, 0x79, 0x31, + 0x3C, 0x13, 0xF5, 0x2C, 0x97, 0x28, 0xBD, 0x1F, 0x2E, 0x68, 0xAB, 0xA1, 0x52, 0x5F, 0xBB, 0x2A, + 0xCB, 0x11, 0xFE, 0x4A, 0x34, 0x30, 0xCD, 0xDD, 0x38, 0xAC, 0xED, 0xD0, 0x53, 0xC6, 0xC4, 0x33, + 0xE5, 0x17, 0x41, 0xC8, 0x7D, 0x14, 0x9C, 0x8C, 0x2D, 0x59, 0x61, 0xB1, 0xEC, 0x6A, 0x48, 0xAD, + 0xC7, 0x42, 0x79, 0x9B, 0x63, 0xDB, 0xB0, 0xAD, 0xAF, 0x44, 0x85, 0x2E, 0x24, 0x11, 0xE6, 0x1E, + 0x56, 0xB2, 0x1B, 0x2E, 0x98, 0x7E, 0x64, 0x3D, 0x98, 0x69, 0x51, 0x05, 0x3D, 0x5C, 0x0A, 0x85, + 0xCA, 0x58, 0x0E, 0x11, 0x86, 0xA7, 0xD6, 0xAC, 0xFF, 0x21, 0x12, 0x9F, 0xA1, 0x52, 0xE4, 0xD9, + 0xD5, 0xAC, 0x9B, 0xE2, 0x4B, 0xF0, 0x57, 0xFA, 0xFC, 0x05, 0x84, 0xB6, 0xD9, 0xB0, 0xCE, 0x5E, + 0xA0, 0x73, 0x32, 0xCE, 0x15, 0x29, 0xE8, 0x8F, 0xC4, 0xD9, 0x22, 0x3A, 0x9D, 0x71, 0xC5, 0x37, + 0x2B, 0x33, 0x76, 0x63, 0x49, 0x52, 0x8A, 0x2E, 0x89, 0x6D, 0x5A, 0x04, 0x83, 0xC1, 0xD9, 0x46, + 0xC3, 0x5C, 0x93, 0x6C, 0x3B, 0xDB, 0xFC, 0x1C, 0xC1, 0x65, 0x3B, 0x2C, 0xAD, 0xD5, 0x78, 0x9A, + 0x3A, 0xE4, 0xC3, 0x04, 0x11, 0xD8, 0xBD, 0x63, 0xA9, 0x93, 0x01, 0xF1, 0x42, 0x89, 0x5E, 0x66, + 0x95, 0xF2, 0x75, 0x38, 0x30, 0x4B, 0x39, 0x41, 0x49, 0x54, 0x8E, 0x12, 0x36, 0xFB, 0x9A, 0xA0, + 0x61, 0x13, 0x1C, 0xC2, 0xB2, 0x30, 0x7E, 0xD5, 0x22, 0xEB, 0xA3, 0xB6, 0x69, 0x2E, 0x0F, 0x0B, + 0xB0, 0x29, 0xF3, 0x24, 0x5A, 0x29, 0xA6, 0x3F, 0xC9, 0xC1, 0x56, 0xC5, 0x8E, 0xAA, 0x0B, 0x17, + 0x44, 0xBC, 0xFF, 0xE3, 0x12, 0xB8, 0x3E, 0xA9, 0x16, 0xF9, 0x7F, 0x57, 0x92, 0x7C, 0x0C, 0xFD, + 0x87, 0x9D, 0x70, 0xED, 0x81, 0xD0, 0x77, 0x01, 0x77, 0x71, 0xF5, 0x6C, 0x7F, 0xCC, 0xE4, 0xF0, + 0xAD, 0x27, 0x66, 0x2D, 0x16, 0x7B, 0x4E, 0x95, 0xF9, 0x59, 0xAA, 0x8A, 0x83, 0xE3, 0x1E, 0xD9, + 0x6E, 0x9C, 0x84, 0xEB, 0xBD, 0x5B, 0x33, 0x68, 0xA9, 0x3F, 0xDA, 0x69, 0xCB, 0xF1, 0xC7, 0x64, + 0x99, 0x27, 0xEF, 0xFF, 0xE2, 0x37, 0x34, 0x2D, 0x3C, 0x92, 0xAF, 0x7B, 0xE6, 0x6D, 0x7E, 0xF9, + 0xD2, 0x95, 0x14, 0xF1, 0x01, 0x93, 0xF2, 0xBD, 0xDF, 0x59, 0x67, 0xF6, 0x2D, 0x36, 0xBB, 0x8E, + 0x16, 0xCA, 0x07, 0xEC, 0x34, 0xA0, 0xE2, 0x16, 0x6C, 0xEC, 0x23, 0x41, 0x87, 0x7A, 0x66, 0x82, + 0x09, 0x6A, 0xFE, 0x21, 0xB3, 0x9A, 0xC7, 0x12, 0x0D, 0x07, 0xEB, 0xCF, 0xCB, 0x44, 0x9B, 0xA3, + 0xA1, 0xD9, 0x07, 0x76, 0x1D, 0x93, 0x96, 0x1B, 0x6D, 0xA1, 0x65, 0x6D, 0xB2, 0x62, 0x81, 0x55, + 0xFD, 0xE1, 0x76, 0xF2, 0x6F, 0x9A, 0x71, 0x9F, 0xFC, 0x48, 0x8D, 0x58, 0x1D, 0x3E, 0xFE, 0xBC, + 0x02, 0xB5, 0x36, 0xEE, 0x58, 0x35, 0x82, 0xF3, 0x51, 0x93, 0x35, 0x7E, 0xFA, 0xAF, 0x7E, 0x56, + 0x7E, 0xE8, 0x59, 0x7E, 0x90, 0x73, 0x9B, 0x0E, 0x4D, 0x0D, 0x84, 0x75, 0x30, 0x29, 0xCA, 0xE7, + 0x2C, 0xB3, 0xAC, 0x53, 0x3C, 0xC3, 0x7D, 0x55, 0xCD, 0xE0, 0xB9, 0xF8, 0x44, 0x02, 0xF2, 0x2B, + 0xB7, 0xD1, 0x83, 0x75, 0xDC, 0x96, 0xE7, 0x62, 0x5A, 0x58, 0x63, 0x2D, 0xC1, 0x33, 0xD2, 0x74, + 0x27, 0x05, 0xFD, 0xB7, 0x69, 0x63, 0x34, 0x81, 0xDB, 0xC1, 0x24, 0x10, 0x3A, 0xC2, 0xE2, 0xE9, + 0x75, 0xF8, 0x90, 0x50, 0x3A, 0x3C, 0xAF, 0xCD, 0x4E, 0x78, 0xB0, 0xFA, 0x5F, 0x2C, 0x09, 0x90, + 0xFE, 0xDA, 0xE4, 0x99, 0x8E, 0x3E, 0x63, 0x74, 0x3C, 0x6C, 0xD6, 0xC5, 0x2A, 0x1A, 0xBD, 0x95, + 0xA3, 0xAB, 0xF3, 0xEF, 0x1E, 0x95, 0x02, 0x8E, 0xCB, 0x23, 0xED, 0x11, 0xDB, 0x42, 0x45, 0xD5, + 0x5D, 0xDF, 0xF6, 0xE5, 0x98, 0xB4, 0x46, 0x49, 0x1A, 0xC6, 0x87, 0xFC, 0xA1, 0x79, 0x15, 0xD8, + 0x84, 0x99, 0xFE, 0x0B, 0x33, 0x30, 0x21, 0xA7, 0x59, 0x0A, 0x35, 0xE6, 0x68, 0x62, 0x55, 0x58, + 0xB4, 0x74, 0xDC, 0x80, 0xA4, 0xAD, 0x97, 0x57, 0x08, 0x9D, 0xC9, 0x9C, 0x1C, 0x0E, 0xD6, 0xE5, + 0xE3, 0xC8, 0x13, 0x02, 0xA8, 0xB9, 0x06, 0x27, 0x55, 0x89, 0xE7, 0xA3, 0xBF, 0xB0, 0xA6, 0xD0, + 0x92, 0xAD, 0xDA, 0xFE, 0x9E, 0x38, 0x2B, 0x88, 0x18, 0x7E, 0x3E, 0x90, 0xC3, 0xC0, 0x90, 0xAB, + 0x10, 0x21, 0x49, 0x47, 0xD1, 0x9D, 0x0A, 0xE9, 0x9F, 0xF9, 0xBB, 0x44, 0x83, 0x43, 0xBE, 0xBB, + 0x72, 0xD3, 0x06, 0xB4, 0x1B, 0x11, 0x03, 0xB8, 0xF5, 0xE5, 0x85, 0x1C, 0x4D, 0x7B, 0x0E, 0x65, + 0x33, 0xB0, 0x06, 0xD4, 0x58, 0x1F, 0xC9, 0x52, 0x27, 0xAD, 0xC9, 0xDE, 0x33, 0x4D, 0xC5, 0x45, + 0x6F, 0x11, 0xE1, 0x1D, 0xB9, 0x26, 0xED, 0x5B, 0x9B, 0xF6, 0xFC, 0x87, 0xF7, 0x96, 0x58, 0x5D, + 0xD7, 0x10, 0x15, 0x59, 0x1E, 0x3C, 0xFC, 0xF2, 0x8C, 0x7B, 0xB8, 0x70, 0x35, 0xD2, 0xB3, 0xA2, + 0xF1, 0xE7, 0x9D, 0xC6, 0xAE, 0x37, 0x71, 0xDA, 0x04, 0x32, 0x09, 0x33, 0xF7, 0x7D, 0x45, 0x33, + 0x9F, 0x5C, 0xD6, 0x66, 0xEC, 0x68, 0xCA, 0xEC, 0xBF, 0x4C, 0xF8, 0xA1, 0x4D, 0x5C, 0x41, 0x0E, + 0x69, 0x1F, 0x96, 0xE8, 0xD9, 0x76, 0xB9, 0xEA, 0x04, 0xEF, 0x91, 0xD4, 0xD7, 0x36, 0xEF, 0xE9, + 0xE6, 0x7B, 0x81, 0x31, 0xFD, 0x4E, 0x15, 0x17, 0xF1, 0x25, 0x86, 0x4C, 0x94, 0x2A, 0xAA, 0x50, + 0xB0, 0x98, 0x19, 0xB4, 0x34, 0x81, 0xE2, 0x61, 0xE6, 0xEE, 0x9C, 0x70, 0x72, 0x38, 0xB8, 0xE8, + 0xA6, 0xE1, 0x9F, 0x24, 0xDC, 0xD2, 0x9D, 0xC3, 0x94, 0x43, 0x65, 0x5B, 0x22, 0x45, 0xF2, 0x75, + 0x33, 0x6D, 0xB9, 0x60, 0xC6, 0x9F, 0x0A, 0xC1, 0x1F, 0xFC, 0x8B, 0x7B, 0xAB, 0x71, 0x61, 0xAE, + 0xD2, 0x1B, 0xF6, 0x79, 0x3D, 0x63, 0x1F, 0x4F, 0x1C, 0xDD, 0x4B, 0x50, 0x02, 0x97, 0xCD, 0xF4, + 0xC7, 0x0B, 0xFC, 0xB3, 0xD1, 0x21, 0xD3, 0x73, 0x1B, 0x4B, 0xE8, 0x9F, 0x3D, 0x16, 0x88, 0x0E, + 0x7F, 0xCC, 0x26, 0xA6, 0xF5, 0x8F, 0x69, 0x7F, 0xAC, 0xE8, 0x3F, 0x7B, 0x29, 0x81, 0xDA, 0x14, + 0x8F, 0x98, 0x78, 0x11, 0x34, 0x46, 0x60, 0xAD, 0x9E, 0xB3, 0x69, 0xFD, 0x74, 0x95, 0x3A, 0x14, + 0x30, 0xBE, 0x34, 0xE2, 0xAC, 0x54, 0x81, 0x70, 0x1F, 0x47, 0xD7, 0x5A, 0xDE, 0x81, 0x29, 0x17, + 0x9B, 0x3F, 0xC7, 0x57, 0x56, 0x26, 0xCD, 0xF8, 0x3B, 0x4E, 0x94, 0x4E, 0xA4, 0x09, 0x46, 0x1A, + 0x6D, 0xA3, 0x44, 0x51, 0xA9, 0x9F, 0x97, 0x88, 0x5E, 0x5E, 0x70, 0xCA, 0xDE, 0xA4, 0xAF, 0x6D, + 0xBC, 0xCE, 0xF6, 0x67, 0x81, 0x10, 0xD3, 0xF5, 0xB8, 0xC9, 0x49, 0xF3, 0x98, 0x71, 0x2D, 0x29, + 0xBD, 0x34, 0x08, 0x25, 0x1B, 0x9A, 0x6F, 0xC3, 0x4D, 0xC3, 0x9F, 0x5E, 0xE2, 0xA2, 0xF3, 0x82, + 0x52, 0xA9, 0xF6, 0x79, 0x14, 0x6F, 0xD0, 0x12, 0xB6, 0x0D, 0x4C, 0xAC, 0x3E, 0x2A, 0x8C, 0x86, + 0xE1, 0xFF, 0x1C, 0x49, 0x43, 0xF2, 0x1D, 0x34, 0xA3, 0x0F, 0xA3, 0x9B, 0x2C, 0xF3, 0x9C, 0xFC, + 0x23, 0x4B, 0xE0, 0xCB, 0xE6, 0xBE, 0x7E, 0x8B, 0x51, 0x2D, 0x32, 0x92, 0xCC, 0xC6, 0xDB, 0x36, + 0x1B, 0x83, 0x80, 0x64, 0xD2, 0x23, 0x1C, 0x60, 0x90, 0x1C, 0x71, 0x06, 0x0F, 0x30, 0xC0, 0xDF, + 0xFE, 0xF7, 0x50, 0x5A, 0xF8, 0x9C, 0x97, 0x29, 0xFB, 0x7B, 0xEB, 0x91, 0x6A, 0x42, 0xE4, 0xAB, + 0x62, 0xB4, 0x1F, 0x14, 0xEC, 0x1A, 0x9F, 0xC4, 0x98, 0x77, 0x85, 0x8B, 0xF1, 0x15, 0x2B, 0x2C, + 0x3F, 0xAB, 0x3A, 0x5E, 0xD3, 0x50, 0x32, 0xDD, 0x23, 0x81, 0x89, 0x3B, 0xB8, 0xFD, 0x49, 0x78, + 0xA9, 0x35, 0x20, 0x2D, 0xBC, 0xFC, 0x10, 0x8A, 0x08, 0xA0, 0x57, 0x24, 0xFA, 0x29, 0xD3, 0x9C, + 0xC0, 0xC5, 0x06, 0xF2, 0x7D, 0xC4, 0x45, 0x38, 0x1F, 0xC6, 0xE4, 0xC8, 0x23, 0x65, 0xD2, 0x5A, + 0xE5, 0xCD, 0x63, 0x14, 0x56, 0x03, 0xAA, 0x29, 0x82, 0xAB, 0x67, 0x92, 0x2C, 0x71, 0x67, 0x6A, + 0x36, 0xF9, 0xE1, 0x89, 0xD2, 0x98, 0x88, 0x97, 0x65, 0x72, 0xE4, 0x3C, 0x5A, 0x1D, 0xB7, 0x34, + 0x4D, 0x01, 0x91, 0x5D, 0xC4, 0xAF, 0x88, 0x2F, 0xD1, 0x27, 0x26, 0x36, 0x16, 0x98, 0x39, 0x9A, + 0xEA, 0xFA, 0xDF, 0x3B, 0x7F, 0xD8, 0x76, 0x95, 0xDB, 0x03, 0x82, 0x86, 0xD0, 0x6D, 0x15, 0xD0, + 0xF0, 0xB9, 0xCC, 0xB9, 0xD6, 0xE1, 0x9C, 0xC7, 0xAE, 0x3C, 0xA8, 0xB9, 0x49, 0xA3, 0xC4, 0xB3, + 0x24, 0x3A, 0xA3, 0x50, 0x7E, 0xDF, 0xBE, 0x5F, 0xAF, 0xC3, 0x7C, 0x3C, 0xC7, 0x39, 0xD9, 0x29, + 0x06, 0xD5, 0x0B, 0xE8, 0xFA, 0x80, 0xC2, 0xCE, 0xA8, 0xD9, 0x20, 0xCE, 0x28, 0x0A, 0xDE, 0x15, + 0xB5, 0x0D, 0x9A, 0xB8, 0xB0, 0x7B, 0x33, 0xB8, 0x35, 0xEB, 0x4E, 0xDE, 0xF5, 0x9F, 0x66, 0x79, + 0x52, 0x44, 0xD2, 0x49, 0x3A, 0x94, 0xE2, 0xCB, 0x83, 0x22, 0x7D, 0xC6, 0x1C, 0xEB, 0x44, 0x28, + 0xE9, 0x38, 0x8F, 0xB7, 0xF6, 0x3D, 0x39, 0x8F, 0x64, 0x9F, 0x86, 0x85, 0x27, 0x7E, 0xBF, 0xD8, + 0xC3, 0x8B, 0x70, 0xF9, 0x7A, 0xE6, 0x19, 0xAF, 0xA8, 0x8F, 0x6C, 0x38, 0xE2, 0xB4, 0x1E, 0xF3, + 0xDD, 0xFD, 0x6C, 0xB4, 0x04, 0xB4, 0xD1, 0x37, 0xF4, 0x59, 0xFF, 0x5A, 0x8B, 0x73, 0x6B, 0x62, + 0x6C, 0x91, 0x23, 0x96, 0x61, 0xEC, 0x9F, 0xF6, 0x83, 0x18, 0xD9, 0xEE, 0xEF, 0x00, 0xB0, 0xEB, + 0x8D, 0xC6, 0x35, 0xCE, 0xB4, 0xE0, 0xBB, 0x84, 0xD3, 0xD7, 0xDB, 0x77, 0x4A, 0x07, 0xE7, 0x3B, + 0xF7, 0x12, 0xF8, 0x9D, 0xF5, 0x0A, 0xDF, 0xF4, 0x1B, 0x00, 0x1A, 0x77, 0xD9, 0x03, 0x21, 0xC2, + 0x46, 0xF7, 0x7E, 0x4B, 0xE2, 0xC1, 0xF1, 0x8D, 0xFE, 0x61, 0xB9, 0xD4, 0x0B, 0xC9, 0x65, 0x82, + 0xCF, 0x7F, 0x3D, 0x24, 0x9E, 0xC9, 0x97, 0x30, 0xE9, 0x81, 0xB4, 0x6B, 0xA5, 0x6A, 0xA7, 0xED, + 0xE3, 0x8F, 0x88, 0x09, 0x78, 0x36, 0x6A, 0x14, 0xB9, 0xBB, 0x93, 0xE6, 0xA2, 0x07, 0x72, 0x81, + 0xD2, 0x41, 0x75, 0x28, 0x50, 0x57, 0xDE, 0x68, 0x04, 0xB1, 0x0F, 0x1F, 0xCF, 0x0F, 0x3E, 0xCB, + 0x44, 0x3D, 0x2A, 0x01, 0xC1, 0x38, 0x61, 0x8E, 0xA1, 0x13, 0xB8, 0x82, 0x3F, 0xAC, 0xA7, 0x31, + 0x7B, 0xF7, 0xA7, 0xCD, 0xBF, 0x15, 0xD3, 0xC2, 0xCC, 0xDC, 0xD0, 0xB2, 0xC1, 0x44, 0xBA, 0x82, + 0x85, 0x2D, 0x59, 0x53, 0xE4, 0xBE, 0x6B, 0x69, 0x8F, 0x5C, 0x20, 0x38, 0x76, 0xE0, 0x49, 0x59, + 0x32, 0x0A, 0x90, 0x42, 0x13, 0x35, 0x24, 0x71, 0xD9, 0x98, 0x9A, 0x0F, 0x0A, 0x83, 0x90, 0x47, + 0xD0, 0x57, 0x29, 0xC8, 0xF5, 0x5B, 0xA8, 0x5D, 0x41, 0xCD, 0x61, 0x98, 0x5C, 0x28, 0x1B, 0xF2, + 0x9B, 0x31, 0x3F, 0x14, 0x79, 0x37, 0xEA, 0xDD, 0x42, 0xD3, 0x59, 0x20, 0x0D, 0x5A, 0x3D, 0x59, + 0x84, 0x1A, 0x48, 0x28, 0x6D, 0x48, 0x3B, 0x0C, 0x87, 0xB0, 0xBB, 0xEF, 0x72, 0x91, 0x85, 0xE0, + 0x9A, 0x2C, 0x78, 0xAF, 0xFE, 0x0D, 0x6D, 0x9A, 0x99, 0x10, 0x16, 0x7D, 0x42, 0x76, 0xA0, 0xAA, + 0xC7, 0xF9, 0x11, 0x5C, 0x04, 0x83, 0x0A, 0xA9, 0x48, 0x65, 0x28, 0x81, 0x65, 0x2E, 0xA7, 0x5A, + 0xFE, 0xDB, 0x10, 0x56, 0xEA, 0x19, 0x67, 0xC2, 0x61, 0xBB, 0x9B, 0x6B, 0x48, 0x4F, 0x22, 0x4C, + 0xB7, 0xEC, 0x15, 0x84, 0x08, 0x1A, 0xFE, 0x08, 0x46, 0xCA, 0x72, 0x10, 0x30, 0x81, 0xAE, 0xE7, + 0x1B, 0xAA, 0x2F, 0x1B, 0x22, 0x6A, 0x89, 0x95, 0x34, 0x9F, 0x53, 0xE4, 0xDA, 0x0B, 0x1B, 0x56, + 0xB4, 0xB7, 0x71, 0x99, 0xB8, 0x77, 0x91, 0xEB, 0x59, 0x61, 0x71, 0x84, 0xAF, 0x55, 0xBD, 0x33, + 0x1C, 0xD9, 0x7A, 0x40, 0xD3, 0x7B, 0x6C, 0xB0, 0xA4, 0x96, 0x07, 0x57, 0x49, 0x9C, 0xC1, 0x0B, + 0x23, 0xF3, 0xE5, 0x36, 0xA4, 0xE8, 0xE1, 0xEC, 0x51, 0xF1, 0xBB, 0x7B, 0x40, 0x4B, 0x05, 0xD1, + 0x3D, 0xD6, 0x6D, 0x22, 0x7C, 0x9D, 0x51, 0x28, 0x70, 0xF6, 0xB3, 0x0C, 0x6F, 0xB2, 0xE1, 0xBC, + 0xFF, 0xB8, 0xA3, 0x92, 0x7C, 0x0A, 0xA3, 0x36, 0x6D, 0xF8, 0xFC, 0x27, 0x45, 0x58, 0x94, 0xE0, + 0x0A, 0x90, 0xF8, 0x2A, 0xF3, 0x02, 0xA4, 0x98, 0xD8, 0xEF, 0x1C, 0x53, 0xE2, 0x47, 0xC7, 0x20, + 0xB2, 0x6F, 0xB7, 0x39, 0x5A, 0xA9, 0x49, 0xC2, 0x65, 0x18, 0x50, 0xBD, 0x7F, 0xB0, 0xDE, 0xBB, + 0x2F, 0x56, 0xDD, 0x62, 0x85, 0xAC, 0x3B, 0x7E, 0xCD, 0x00, 0x88, 0x7A, 0x22, 0xC5, 0x03, 0x03, + 0x26, 0xC4, 0x27, 0x09, 0xE8, 0x16, 0x36, 0xB7, 0x0B, 0xDF, 0xDA, 0x21, 0xEB, 0x59, 0xE8, 0x6D, + 0x96, 0x2D, 0x18, 0x89, 0xD4, 0x4E, 0x5A, 0x66, 0x63, 0x31, 0x15, 0xF0, 0x48, 0x50, 0x7A, 0xF3, + 0xA7, 0x82, 0xE0, 0x91, 0x04, 0xB2, 0x16, 0xAC, 0xA1, 0xD4, 0xC1, 0xE4, 0xBD, 0xC9, 0x43, 0x83, + 0xD9, 0x18, 0x11, 0x50, 0xC0, 0x93, 0x9D, 0x6B, 0x17, 0x63, 0xC8, 0xA3, 0xAF, 0xAC, 0xBF, 0x29, + 0x65, 0xA6, 0x4A, 0xE4, 0xCD, 0xE2, 0x89, 0x59, 0xF8, 0x96, 0xF8, 0x3B, 0x80, 0xCA, 0x68, 0xF2, + 0xBF, 0xBE, 0xFD, 0xD0, 0x84, 0x88, 0xE3, 0x3D, 0x08, 0x8A, 0x08, 0x39, 0xDC, 0x88, 0x71, 0x61, + 0x76, 0xAD, 0xB6, 0xBE, 0xC0, 0xA4, 0x28, 0xEE, 0x38, 0x8F, 0x2E, 0x8D, 0x3A, 0x28, 0xAE, 0xEB, + 0x93, 0x7E, 0xF4, 0x2E, 0x5F, 0x3B, 0xEA, 0x37, 0x9A, 0x53, 0x6C, 0xC5, 0x3A, 0x2F, 0x7F, 0xA9, + 0x80, 0x85, 0x18, 0xFE, 0x14, 0x0C, 0x37, 0xA7, 0xE2, 0x78, 0x90, 0x20, 0x1F, 0x41, 0x1C, 0x03, + 0xD1, 0xD0, 0x8C, 0xB2, 0x2D, 0x4C, 0x32, 0x81, 0x63, 0xF6, 0x6F, 0xD3, 0x7F, 0xB4, 0x6D, 0xA8, + 0xD6, 0xE0, 0x56, 0x84, 0xAD, 0x37, 0x96, 0x44, 0xB4, 0xAE, 0x6F, 0x49, 0x3E, 0x30, 0x0C, 0x79, + 0xE3, 0x93, 0xBA, 0xD2, 0x10, 0x71, 0xAC, 0x7C, 0x06, 0x89, 0x26, 0xCB, 0x72, 0x9E, 0xC4, 0xCC, + 0xBB, 0xA1, 0xDE, 0x9B, 0x66, 0x75, 0x6F, 0xAC, 0x51, 0x93, 0xE8, 0xF4, 0x43, 0xE4, 0x79, 0xF2, + 0x50, 0x67, 0x3D, 0x1B, 0x33, 0xB5, 0xEC, 0x93, 0x10, 0xCE, 0x78, 0x3C, 0x0C, 0x25, 0x44, 0x30, + 0x3C, 0xAB, 0x40, 0x6F, 0x4B, 0x54, 0x0C, 0x38, 0xD4, 0xEF, 0x18, 0xED, 0xA5, 0x75, 0x1E, 0x9C, + 0x06, 0x42, 0x11, 0x9D, 0xEC, 0xE8, 0x81, 0x38, 0xBE, 0xEF, 0x21, 0xB5, 0x0A, 0xC3, 0x38, 0x94, + 0x0C, 0x5A, 0xE2, 0x47, 0xDC, 0x2E, 0x82, 0xC3, 0xA6, 0x9D, 0xA6, 0x54, 0x5E, 0xE6, 0x7C, 0xFE, + 0x7E, 0x7B, 0x86, 0x9A, 0x54, 0xEC, 0xCD, 0xE5, 0x9F, 0xF7, 0x23, 0xDE, 0x06, 0x90, 0x93, 0xB6, + 0xCC, 0xC8, 0x3D, 0x75, 0xA6, 0x43, 0xEA, 0x1F, 0x44, 0xAB, 0xBB, 0x15, 0xC4, 0xAB, 0xB1, 0xDF, + 0xE9, 0x30, 0xB4, 0xB2, 0x3B, 0x5B, 0xA6, 0x57, 0xEE, 0x25, 0x4B, 0x83, 0x26, 0xE4, 0x6B, 0xE3, + 0x35, 0x62, 0xA5, 0xD2, 0xB6, 0xDE, 0xFD, 0x5F, 0x8C, 0x21, 0xF8, 0x15, 0x41, 0x1C, 0x61, 0xCD, + 0x78, 0x0F, 0x61, 0x9E, 0x0C, 0x7E, 0x88, 0xE3, 0x34, 0x7F, 0x0B, 0x00, 0x5D, 0x8A, 0x37, 0x5F, + 0xFB, 0x65, 0xB8, 0xEC, 0x6C, 0x6A, 0x7E, 0x8F, 0x70, 0x6A, 0x17, 0xFB, 0x6B, 0x9D, 0xD8, 0xC3, + 0xD5, 0x13, 0x49, 0xEC, 0xD0, 0xEC, 0x1B, 0xC7, 0x79, 0xBB, 0xD2, 0x89, 0x96, 0x39, 0x1C, 0xF3, + 0x70, 0xEA, 0xF0, 0xEA, 0x6B, 0x45, 0x51, 0xDB, 0x1A, 0x61, 0x60, 0x98, 0x1C, 0x7A, 0xA6, 0x48, + 0x65, 0xDA, 0x85, 0xBE, 0x6B, 0xC4, 0x27, 0x2F, 0x76, 0x6D, 0x5F, 0x4C, 0xDE, 0x92, 0xA1, 0xB3, + 0xD4, 0x11, 0xB4, 0x0B, 0x3A, 0x4C, 0x73, 0xC3, 0xAA, 0x9C, 0x0F, 0x95, 0x9B, 0x2C, 0x67, 0x02, + 0x47, 0xCD, 0xE3, 0x75, 0x84, 0x60, 0x5E, 0x17, 0xAB, 0xF0, 0xBC, 0xBE, 0xB4, 0xAA, 0x4C, 0xEA, + 0x11, 0x52, 0x87, 0xAC, 0x16, 0x56, 0x06, 0x1F, 0xC1, 0x97, 0xF9, 0xAB, 0x26, 0xD9, 0xCC, 0x58, + 0x01, 0xFF, 0x44, 0x21, 0xFE, 0x5D, 0x53, 0x0B, 0xA2, 0xAF, 0xBC, 0x9D, 0x63, 0x25, 0x87, 0x66, + 0xB3, 0x79, 0xB4, 0x9F, 0x49, 0xE6, 0x6E, 0xCB, 0x8B, 0x39, 0x8C, 0x46, 0x60, 0x3D, 0x5B, 0xEC, + 0x08, 0x1B, 0xB2, 0xEC, 0xA2, 0xAA, 0x9A, 0xDA, 0xAA, 0xAD, 0x25, 0xAB, 0x45, 0x99, 0x63, 0x23, + 0x6C, 0x53, 0x87, 0xA0, 0x5A, 0x6C, 0xD6, 0xE3, 0x6C, 0x34, 0x42, 0x0F, 0xF3, 0xA0, 0x23, 0xD3, + 0x16, 0x05, 0xAB, 0x05, 0x14, 0xA8, 0xA9, 0x02, 0x23, 0xFC, 0xC0, 0xED, 0x75, 0xC5, 0x43, 0x7C, + 0x1E, 0xB1, 0x69, 0xB6, 0x01, 0x96, 0x7B, 0x9E, 0x12, 0x1C, 0x72, 0x42, 0x0D, 0xAB, 0x0B, 0x79, + 0x22, 0xF3, 0xF0, 0xEB, 0x71, 0x83, 0x42, 0x3C, 0x11, 0xC7, 0x4F, 0x87, 0xFF, 0x5D, 0x19, 0x0B, + 0xE4, 0x1E, 0xC3, 0xA2, 0xD7, 0x0E, 0x9C, 0x3C, 0x7D, 0xFB, 0x4F, 0xDA, 0x99, 0x9F, 0xF8, 0x3E, + 0xD4, 0xA0, 0xA2, 0xF8, 0x83, 0x33, 0x1E, 0xE2, 0x1C, 0x52, 0x9D, 0xB8, 0x63, 0x8F, 0xA1, 0x4D, + 0x68, 0xAE, 0xCE, 0xD4, 0x12, 0x8E, 0x96, 0xA1, 0x78, 0x27, 0x6A, 0x29, 0x11, 0x19, 0x4C, 0x94, + 0x89, 0x0F, 0xFB, 0x7C, 0xA8, 0xAC, 0x7E, 0x84, 0x44, 0xC8, 0x7A, 0x18, 0xAE, 0x34, 0x0F, 0x6E, + 0x90, 0xDB, 0x1E, 0x79, 0xFA, 0xE8, 0xAF, 0x71, 0xE4, 0x80, 0x24, 0x53, 0x2F, 0xB6, 0xC2, 0x12, + 0x1F, 0xA0, 0x44, 0x98, 0x40, 0xAE, 0x01, 0xD6, 0xFB, 0x86, 0xBB, 0xC6, 0xF7, 0x2F, 0x38, 0x41, + 0xE3, 0x2E, 0x1F, 0x2E, 0x7C, 0x90, 0x1F, 0xD9, 0xD3, 0x34, 0x86, 0xC8, 0xA3, 0x8E, 0xAB, 0x5E, + 0x05, 0x55, 0x71, 0x5B, 0x21, 0xB7, 0x2F, 0x9E, 0x56, 0x32, 0x56, 0xD1, 0xDC, 0xC9, 0xDA, 0xDE, + 0xAC, 0x1D, 0x91, 0x0E, 0x4D, 0x1F, 0x4F, 0xE7, 0x31, 0xFE, 0x9A, 0x3F, 0x18, 0xAD, 0x85, 0x4E, + 0x66, 0x95, 0x76, 0x67, 0x6A, 0xC8, 0x90, 0x6A, 0xB5, 0xB0, 0x7D, 0xB2, 0xB3, 0xD7, 0xD6, 0x42, + 0xF1, 0x63, 0x52, 0xBD, 0x72, 0xE1, 0xD2, 0x63, 0x9A, 0x00, 0x45, 0x8E, 0x77, 0xCF, 0x93, 0xCF, + 0x1A, 0x31, 0xAA, 0x16, 0xA9, 0xCF, 0x45, 0xE3, 0x99, 0x3E, 0x6C, 0x70, 0xE9, 0x93, 0x83, 0x78, + 0x11, 0xB8, 0x80, 0xEA, 0x75, 0x5A, 0x87, 0xCE, 0x1D, 0xCD, 0x12, 0x5F, 0x1F, 0x6F, 0x86, 0x25, + 0x5E, 0x95, 0x22, 0x07, 0xFE, 0x29, 0xDA, 0x93, 0x52, 0x41, 0x62, 0x79, 0x06, 0x06, 0x83, 0xAE, + 0x42, 0x35, 0x5C, 0x9E, 0x01, 0xF8, 0xFA, 0x3F, 0x07, 0x15, 0xCA, 0x02, 0x69, 0x8E, 0xEA, 0x9E, + 0xEF, 0xF4, 0x99, 0x26, 0x73, 0x42, 0xC2, 0xEC, 0x0F, 0xEC, 0x03, 0x8F, 0x66, 0xC1, 0x88, 0x76, + 0xC5, 0xC2, 0x55, 0x46, 0x59, 0xC4, 0x28, 0x55, 0x93, 0xBF, 0x7C, 0x1C, 0x5C, 0xA0, 0xBA, 0x8A, + 0xCA, 0x8A, 0x81, 0x6C, 0xA3, 0xDE, 0x2D, 0x63, 0xC5, 0xCA, 0x0B, 0x8E, 0x99, 0xC9, 0xE4, 0x7E, + 0x32, 0x36, 0xD8, 0xFA, 0x80, 0xA5, 0x93, 0x4F, 0x5C, 0x97, 0x33, 0x74, 0xD2, 0x03, 0xFF, 0xFD, + 0x57, 0x84, 0x26, 0x62, 0x6A, 0x4C, 0x15, 0x45, 0xB9, 0x7C, 0xCD, 0xD8, 0x7B, 0xC5, 0x70, 0xA1, + 0xCB, 0xB4, 0xDE, 0xA6, 0xBD, 0xE0, 0xE9, 0x49, 0xB7, 0xEA, 0x21, 0x17, 0xCD, 0x0C, 0xA7, 0xF2, + 0x9B, 0xB6, 0x26, 0x06, 0xB1, 0x63, 0x3D, 0x0D, 0x1A, 0xAE, 0x57, 0xF1, 0x53, 0xDA, 0x61, 0x47, + 0x7E, 0x66, 0xC0, 0x2A, 0xAC, 0x7E, 0xE8, 0xE9, 0x4F, 0xC2, 0x21, 0x01, 0x0B, 0x9C, 0xA7, 0x98, + 0x05, 0x3A, 0x34, 0x68, 0x19, 0x26, 0x35, 0x57, 0xF7, 0xF8, 0xE0, 0x77, 0x7B, 0x42, 0x8D, 0xE0, + 0xD3, 0x08, 0x49, 0x62, 0x1D, 0x86, 0xBE, 0xC8, 0xDC, 0x2F, 0xE0, 0xFF, 0xC4, 0x6E, 0xBD, 0xEC, + 0x8B, 0x33, 0xF1, 0x61, 0x6E, 0x96, 0xEB, 0xEA, 0x87, 0x4C, 0xA3, 0x5F, 0x97, 0x92, 0x22, 0x0C, + 0x36, 0x05, 0xA5, 0xC1, 0xF6, 0xB8, 0xF5, 0xE0, 0xE4, 0x91, 0x73, 0x73, 0xD0, 0x38, 0x81, 0x24, + 0x13, 0xB4, 0x4B, 0xAB, 0x4C, 0xBB, 0x15, 0x56, 0xC2, 0x66, 0xF9, 0x27, 0xEF, 0xE0, 0x3D, 0x4E, + 0xDB, 0x12, 0xCB, 0xC1, 0xDE, 0x57, 0x1B, 0x7F, 0x69, 0x10, 0xE4, 0x6E, 0xF7, 0xCC, 0x0F, 0x64, + 0x31, 0x6A, 0xBF, 0x49, 0x6C, 0xF8, 0x9E, 0xC9, 0x37, 0xF9, 0x26, 0x32, 0x4A, 0x26, 0x97, 0x99, + 0x30, 0xA6, 0x86, 0x82, 0xCE, 0x04, 0x8B, 0xFB, 0x39, 0x3B, 0xEF, 0x05, 0xAE, 0x3F, 0xFD, 0xEA, + 0x21, 0xA7, 0xF9, 0xD8, 0x2D, 0x34, 0x42, 0xE4, 0xDC, 0x40, 0x1C, 0x82, 0x94, 0x89, 0xC4, 0x74, + 0x0C, 0xF6, 0x76, 0x65, 0x13, 0x29, 0x85, 0xE7, 0xF6, 0x8C, 0x19, 0x3D, 0xC2, 0x69, 0x79, 0x07, + 0x8C, 0x47, 0x24, 0x24, 0x4C, 0xD6, 0x41, 0x93, 0x70, 0x40, 0x08, 0x6D, 0x49, 0x4D, 0x92, 0xAA, + 0x9D, 0x02, 0xAB, 0x53, 0x8D, 0x8C, 0x96, 0x75, 0x54, 0xD0, 0xA2, 0x45, 0xBA, 0x19, 0x81, 0xFE, + 0x20, 0xCC, 0x93, 0x78, 0x4D, 0xBB, 0xA2, 0x21, 0xAB, 0xB5, 0x1B, 0x47, 0x0C, 0xA2, 0x34, 0x24, + 0x1E, 0xF3, 0x40, 0xF3, 0xC8, 0x79, 0xAE, 0x00, 0x40, 0xC3, 0xC4, 0x1B, 0x41, 0x5E, 0xF4, 0x08, + 0x7D, 0x15, 0xF1, 0xDF, 0xE2, 0x34, 0x78, 0xC3, 0x2A, 0x91, 0x8D, 0xC1, 0xA7, 0xF4, 0xD0, 0xF9, + 0xE7, 0x4E, 0x9F, 0xDC, 0x56, 0x16, 0x6C, 0x5B, 0x48, 0x10, 0x7E, 0xE9, 0xA6, 0x3F, 0x3B, 0xD0, + 0xFD, 0x12, 0x46, 0x1B, 0xFF, 0x61, 0x76, 0x61, 0xCC, 0x24, 0x1C, 0x94, 0xDF, 0x77, 0x6F, 0xAE, + 0x8E, 0xEE, 0x96, 0xF6, 0x9B, 0xB4, 0xE9, 0xA5, 0x1E, 0x6D, 0x7C, 0x2C, 0x43, 0xFB, 0x74, 0xF3, + 0x23, 0x86, 0xE6, 0x07, 0xC7, 0x36, 0xE3, 0xED, 0xAF, 0xDD, 0x75, 0x61, 0xCD, 0xFE, 0xEE, 0x4B, + 0x82, 0xF7, 0xC7, 0x66, 0x2B, 0x4C, 0xFF, 0x97, 0x77, 0x1A, 0xF5, 0xA5, 0x55, 0xF2, 0xBD, 0xC0, + 0xD4, 0xD8, 0x07, 0x2A, 0x92, 0xB0, 0x04, 0x56, 0x55, 0x3F, 0x1B, 0xCA, 0x21, 0x25, 0x3F, 0xB9, + 0x81, 0x01, 0x94, 0x43, 0xEE, 0x83, 0xD5, 0x10, 0xB4, 0x13, 0x19, 0xC0, 0x06, 0xBA, 0xEF, 0xA3, + 0xE4, 0xEC, 0xD8, 0x66, 0x30, 0x58, 0xA2, 0xE7, 0x81, 0x65, 0xDA, 0xA1, 0x35, 0x28, 0x4B, 0x47, + 0x17, 0x95, 0xA3, 0x8C, 0x67, 0x44, 0xC8, 0x8B, 0x1B, 0x5F, 0xE9, 0x0E, 0x99, 0xA3, 0x39, 0xAF, + 0x5C, 0xCA, 0x0D, 0x68, 0xAD, 0xE0, 0x91, 0xF3, 0x95, 0x54, 0x02, 0xFF, 0xC4, 0x23, 0xA1, 0x2E, + 0xCE, 0xD2, 0xFC, 0x34, 0x5A, 0xF0, 0x83, 0x82, 0x54, 0x07, 0xDE, 0x21, 0x0D, 0xE3, 0xDF, 0x86, + 0xC1, 0x6E, 0xAB, 0x95, 0x28, 0x90, 0xED, 0x3B, 0x93, 0x95, 0x9E, 0xDE, 0xBA, 0x3E, 0x32, 0x85, + 0x0F, 0xB9, 0x62, 0x68, 0x00, 0x93, 0x38, 0xF9, 0x6B, 0x36, 0x5E, 0xAB, 0x9F, 0xDD, 0x84, 0x97, + 0xB8, 0xAB, 0xDA, 0x29, 0x88, 0xEC, 0x9D, 0xFA, 0xAA, 0x34, 0x2B, 0x1E, 0xC0, 0x6C, 0x53, 0xD4, + 0x55, 0x40, 0x45, 0x9F, 0xEC, 0x0A, 0x90, 0x51, 0xC5, 0x7A, 0x8A, 0xF6, 0xEE, 0x62, 0xC2, 0xE9, + 0x57, 0x2A, 0x1D, 0x8F, 0xB6, 0x83, 0xF9, 0x44, 0x42, 0x33, 0x2A, 0x3D, 0xC7, 0x46, 0xDA, 0xCA, + 0xBC, 0x6B, 0x49, 0x7F, 0x94, 0xB0, 0x6C, 0x80, 0xEC, 0x76, 0x96, 0x12, 0xB9, 0x05, 0x47, 0x96, + 0x84, 0x98, 0xCF, 0x8F, 0x21, 0xF5, 0x6B, 0x86, 0xB8, 0xD4, 0x80, 0xBA, 0xEA, 0x3C, 0xF6, 0x7A, + 0x98, 0xE9, 0x1A, 0x5E, 0x2C, 0x69, 0x1A, 0x2A, 0x31, 0xB9, 0xE6, 0x28, 0xA3, 0xCA, 0xC2, 0x70, + 0xDB, 0xF0, 0x30, 0x28, 0xD3, 0xD6, 0x17, 0xAD, 0x73, 0x8D, 0xB3, 0xF5, 0xFD, 0xA3, 0x6D, 0x8A, + 0xAE, 0x7A, 0x69, 0xD7, 0x6E, 0x4C, 0x29, 0x44, 0xBD, 0x57, 0xBA, 0xC9, 0xFD, 0xA1, 0xEF, 0xA9, + 0xA0, 0x98, 0x39, 0x7A, 0x05, 0x61, 0x46, 0x55, 0x77, 0x5C, 0x1A, 0x39, 0x38, 0x98, 0xFA, 0x79, + 0x9A, 0xBC, 0x68, 0xDB, 0x29, 0x51, 0xDD, 0x2C, 0xEC, 0xFA, 0x61, 0x93, 0x93, 0x44, 0xF2, 0x7E, + 0xD7, 0xA2, 0x79, 0xF1, 0xBD, 0x19, 0x81, 0x36, 0x04, 0x3A, 0x26, 0x20, 0x07, 0x3E, 0x01, 0x8E, + 0x16, 0xE0, 0x6F, 0xF6, 0x29, 0xB8, 0x0B, 0xAC, 0x37, 0x19, 0x39, 0x91, 0x09, 0x23, 0xA6, 0x9C, + 0xAD, 0x08, 0x70, 0xA8, 0x66, 0x0A, 0x22, 0xA2, 0x2E, 0xC5, 0xB9, 0x7F, 0x58, 0xC0, 0x2F, 0x07, + 0x61, 0xB9, 0x2D, 0x3F, 0xA9, 0xB1, 0x67, 0x52, 0xC1, 0x1C, 0x2C, 0xB4, 0xFC, 0x02, 0xA8, 0x4F, + 0x71, 0x87, 0x7F, 0x42, 0x35, 0x93, 0x25, 0xF5, 0x81, 0x07, 0xF9, 0x75, 0x01, 0xBE, 0x08, 0x15, + 0xC5, 0xD1, 0xED, 0x91, 0xB6, 0x0B, 0xC8, 0x8B, 0x4D, 0x62, 0x54, 0xD7, 0x14, 0x9C, 0x3E, 0xEA, + 0x15, 0x3E, 0x91, 0x4F, 0x2F, 0xB5, 0x5C, 0x5A, 0x13, 0x6D, 0x24, 0xE5, 0xB1, 0xA2, 0xFC, 0xAF, + 0x5F, 0x85, 0x13, 0x52, 0x9F, 0x80, 0x19, 0xBB, 0xB7, 0x9A, 0xC6, 0x92, 0x49, 0x2D, 0x28, 0xA7, + 0xA2, 0x28, 0xFA, 0x4A, 0x7B, 0xBA, 0x99, 0x15, 0xA9, 0xF3, 0x51, 0xED, 0xA5, 0xD7, 0x9A, 0xC1, + 0x7A, 0x1E, 0x77, 0x57, 0xBB, 0xA7, 0x25, 0x10, 0xE9, 0x69, 0xAC, 0x50, 0xEF, 0xEC, 0x85, 0x02, + 0x52, 0xC9, 0x29, 0xE9, 0xCB, 0xC8, 0xD0, 0x2D, 0x43, 0xAD, 0x26, 0x93, 0xA8, 0x12, 0xE3, 0xEB, + 0xB1, 0x1E, 0xA2, 0x8D, 0xE4, 0xF7, 0x8F, 0x4B, 0x55, 0xE7, 0xD7, 0x98, 0x3B, 0x7B, 0x85, 0x16, + 0xEE, 0x5A, 0xD8, 0x61, 0x65, 0x57, 0xBC, 0x74, 0x62, 0xD3, 0xDC, 0x7C, 0x6D, 0xCC, 0x56, 0xB0, + 0x3B, 0xA7, 0xE9, 0x10, 0xDE, 0x6A, 0xF4, 0x3A, 0xEC, 0x7E, 0x2E, 0xD0, 0x1E, 0x81, 0x48, 0xD3, + 0xEC, 0xD7, 0xC5, 0xDB, 0x16, 0xBD, 0xD5, 0x5B, 0xAD, 0x8E, 0x13, 0x5A, 0x2A, 0x9E, 0x1A, 0x96, + 0xC3, 0x7E, 0x23, 0xAD, 0xA7, 0x45, 0xE0, 0xCE, 0xA4, 0x52, 0x0C, 0x2A, 0x2E, 0x84, 0x9D, 0xB3, + 0xB4, 0x21, 0x18, 0xA7, 0xCF, 0x57, 0xA3, 0xFE, 0xA1, 0x27, 0x99, 0xCE, 0x48, 0x1E, 0xA7, 0xDB, + 0x62, 0x13, 0x9B, 0x19, 0xE3, 0xBF, 0xAA, 0xA2, 0x9D, 0x29, 0xC9, 0x92, 0xD1, 0x5A, 0x43, 0x4E, + 0xC4, 0xF8, 0xB4, 0xD9, 0xFC, 0xBD, 0x1A, 0xBB, 0x4D, 0x23, 0x99, 0xF3, 0x86, 0xE6, 0xBC, 0xB7, + 0x03, 0xE1, 0xA9, 0xD7, 0xDF, 0x5C, 0x15, 0x56, 0xB4, 0x63, 0xC2, 0x71, 0x6D, 0x15, 0xF1, 0x85, + 0xB6, 0xFF, 0x85, 0x4B, 0x6C, 0x36, 0xDB, 0xA8, 0x07, 0x22, 0x92, 0x4F, 0xD5, 0xA3, 0x2B, 0x40, + 0x8F, 0x6D, 0x89, 0xE3, 0x3E, 0xA2, 0x40, 0xAE, 0x80, 0xA5, 0x3A, 0xD2, 0x5D, 0x7E, 0x74, 0x6A, + 0x94, 0xED, 0xA3, 0xF2, 0x4C, 0x2E, 0x57, 0xF2, 0xBE, 0x8B, 0x25, 0xEF, 0x87, 0x0C, 0x05, 0x99, + 0x27, 0x5E, 0xA5, 0xDE, 0xAE, 0x94, 0x49, 0xFD, 0x7A, 0x62, 0xA7, 0x74, 0x58, 0x8A, 0x1A, 0xED, + 0x15, 0x23, 0x1D, 0x83, 0xD7, 0xA4, 0x6B, 0x4F, 0x3F, 0x9C, 0xBB, 0x5B, 0x27, 0xAD, 0x5C, 0x7E, + 0xA2, 0xE0, 0xBF, 0x39, 0x0C, 0x73, 0xB1, 0x48, 0x07, 0xC1, 0x3B, 0xD5, 0xA6, 0x2D, 0x94, 0x20, + 0x6D, 0xE6, 0x91, 0xAD, 0xCC, 0xDE, 0x4A, 0x3C, 0x4C, 0x02, 0x92, 0xCD, 0x41, 0x46, 0x3C, 0x88, + 0x5A, 0xB6, 0xF6, 0x8F, 0x85, 0x05, 0x7E, 0x75, 0xAC, 0x92, 0x92, 0x99, 0xF4, 0x36, 0x21, 0xE9, + 0x0D, 0x19, 0x02, 0xA1, 0xF0, 0xF1, 0xDB, 0xD8, 0x8F, 0x48, 0x11, 0x5D, 0x84, 0x80, 0x24, 0xD8, + 0xEE, 0x57, 0xB2, 0x3A, 0xE6, 0x0E, 0xC5, 0xA1, 0x26, 0xF9, 0x0C, 0x2E, 0x6C, 0x3A, 0x7A, 0x8B, + 0x0B, 0x9B, 0x3D, 0x2E, 0xAF, 0x26, 0x7D, 0x02, 0x63, 0xC8, 0x0D, 0x24, 0x7D, 0x36, 0x19, 0xAB, + 0xAC, 0xA9, 0x10, 0xA0, 0x53, 0x25, 0x4C, 0xC7, 0x4C, 0x28, 0x4A, 0xC3, 0x38, 0x92, 0xE2, 0x3D, + 0xF3, 0xE1, 0x93, 0xDE, 0x3E, 0x77, 0xAC, 0xEF, 0x6A, 0x08, 0x44, 0xE8, 0x20, 0x18, 0xA3, 0xA0, + 0x90, 0x56, 0xDD, 0xAB, 0x77, 0x7D, 0x36, 0xC2, 0x91, 0xB5, 0x44, 0x8C, 0xD4, 0x57, 0x2C, 0x81, + 0xA1, 0xB9, 0xD9, 0x59, 0x50, 0x8A, 0x76, 0x88, 0x5A, 0x5E, 0x45, 0x99, 0xAC, 0x8C, 0x40, 0x14, + 0x46, 0x28, 0x77, 0xED, 0x1C, 0x7C, 0x59, 0x36, 0x83, 0x4A, 0xA7, 0x0A, 0x71, 0x9C, 0x3B, 0x02, + 0x43, 0x50, 0x74, 0x85, 0xE3, 0xD4, 0x0A, 0x3B, 0x1B, 0xE2, 0xD7, 0x1F, 0x79, 0x78, 0x4B, 0x00, + 0x8E, 0x0A, 0x99, 0xDF, 0x14, 0x17, 0xCD, 0xB8, 0xCF, 0x21, 0xB3, 0x85, 0x38, 0xDE, 0x01, 0xBA, + 0x1B, 0x95, 0x4B, 0x97, 0x2B, 0xB0, 0xC9, 0xED, 0x45, 0xCE, 0x22, 0x5B, 0x8E, 0x04, 0x91, 0x07, + 0x58, 0xC8, 0xB5, 0xA7, 0x06, 0x62, 0x9D, 0xC4, 0xAC, 0x1E, 0x08, 0xFD, 0xEA, 0xB7, 0x4D, 0x0B, + 0xD2, 0x79, 0xA8, 0xEF, 0x4F, 0xBE, 0x80, 0xE6, 0x55, 0x44, 0x7B, 0x59, 0x5E, 0x9C, 0x92, 0x6A, + 0x92, 0xF7, 0xE7, 0x78, 0xFB, 0x46, 0xA1, 0xF4, 0x1E, 0x36, 0x8B, 0xE2, 0x86, 0xA2, 0xE1, 0x19, + 0xB5, 0x29, 0xEA, 0xD2, 0x1D, 0x0B, 0x68, 0xC5, 0x2F, 0x4F, 0x48, 0x6A, 0xC8, 0x92, 0xCE, 0x64, + 0x9D, 0xA5, 0x86, 0xA5, 0x05, 0x40, 0xCE, 0xD7, 0x6C, 0x69, 0x9F, 0x6C, 0xB2, 0xA3, 0x11, 0x08, + 0xEF, 0x9B, 0xCD, 0x10, 0x07, 0x7B, 0x9E, 0x25, 0xF4, 0x1A, 0x2B, 0x21, 0x7E, 0xA5, 0xB9, 0xE1, + 0x33, 0x52, 0xFA, 0x04, 0x09, 0xD4, 0x78, 0xCB, 0x56, 0xE6, 0x55, 0x2C, 0xB4, 0x5D, 0xBB, 0x40, + 0x34, 0xE5, 0x23, 0x30, 0xB8, 0x65, 0x19, 0xF1, 0x5A, 0x08, 0xF2, 0xF4, 0x86, 0x45, 0xB7, 0x87, + 0x17, 0xFA, 0x68, 0x6A, 0x1F, 0x7E, 0x69, 0xDA, 0x89, 0x8E, 0xCA, 0xB6, 0xFF, 0x9F, 0x4E, 0x6F, + 0x25, 0x46, 0x46, 0xF6, 0x7B, 0x1E, 0xB3, 0x3D, 0x2C, 0x8C, 0x01, 0xA9, 0x7B, 0xDA, 0xE9, 0x4D, + 0x6E, 0x89, 0x9D, 0x0F, 0x3F, 0x9F, 0x15, 0x3C, 0xFE, 0x35, 0x61, 0x2A, 0x45, 0xC2, 0xA9, 0xC5, + 0x5C, 0x51, 0xCC, 0x6B, 0xCC, 0x2F, 0xA7, 0x60, 0x03, 0x71, 0xF0, 0xB3, 0xBF, 0x7B, 0x76, 0xCC, + 0x89, 0x2C, 0x31, 0x79, 0xE6, 0xDC, 0x7C, 0x39, 0x24, 0xD8, 0x1A, 0x98, 0x1F, 0x98, 0xCD, 0xD4, + 0x7E, 0x04, 0xF2, 0x92, 0x8D, 0x23, 0x03, 0x5F, 0xF3, 0x05, 0x3B, 0xB0, 0x0A, 0xF0, 0x7A, 0xCA, + 0x76, 0xCB, 0xD0, 0xBA, 0xA0, 0x7F, 0xBA, 0x0D, 0x68, 0x60, 0xC3, 0xEF, 0xDC, 0x44, 0x2E, 0x40, + 0x24, 0x9D, 0xCB, 0x1D, 0x5A, 0x0C, 0x51, 0x66, 0x1A, 0x2A, 0x68, 0xA6, 0x83, 0x20, 0x79, 0x9B, + 0x24, 0xEA, 0x10, 0x5A, 0xB4, 0x39, 0x58, 0xAC, 0xA0, 0x45, 0x3B, 0x16, 0xBE, 0x24, 0x59, 0x1D, + 0x18, 0x5C, 0xD8, 0xCD, 0xFE, 0x16, 0x5C, 0x84, 0x5C, 0x2D, 0x7D, 0x28, 0xC9, 0xCE, 0x9D, 0x38, + 0xF6, 0x2F, 0x9A, 0x8A, 0x93, 0x95, 0xDC, 0x73, 0x48, 0xFD, 0xF5, 0xAB, 0xF4, 0x06, 0xB4, 0x11, + 0x79, 0x7B, 0xF7, 0x75, 0x73, 0xC2, 0x2D, 0x9C, 0x91, 0x7E, 0x51, 0x12, 0x54, 0xAC, 0x55, 0x29, + 0x48, 0x7F, 0x50, 0x15, 0xC2, 0x79, 0x05, 0x3C, 0x8F, 0xB4, 0xAE, 0xDD, 0x28, 0x09, 0xCC, 0x1D, + 0xDE, 0xEF, 0x82, 0xFD, 0x64, 0xD1, 0x5A, 0xFE, 0x06, 0x18, 0x7C, 0xF6, 0x32, 0x67, 0xDB, 0xF1, + 0x55, 0xF4, 0x09, 0x33, 0xB4, 0x91, 0xA7, 0x68, 0xE7, 0xA3, 0x60, 0x93, 0xE6, 0x36, 0xDE, 0x28, + 0xB3, 0xBD, 0x90, 0x46, 0x7F, 0xE5, 0xAF, 0x3C, 0xB6, 0x5E, 0xF2, 0x98, 0xE6, 0x28, 0x07, 0xA9, + 0x21, 0x4C, 0xAA, 0xF7, 0x95, 0xD9, 0x25, 0x51, 0x7F, 0x26, 0x8F, 0xC9, 0xD6, 0x65, 0xCA, 0x07, + 0x82, 0x1F, 0x8E, 0xBF, 0xBA, 0x65, 0xF7, 0xB1, 0x51, 0x85, 0x99, 0x23, 0x4E, 0x48, 0x2E, 0x7B, + 0xC8, 0x09, 0xC4, 0x93, 0xB9, 0xDB, 0x6B, 0xAF, 0xCA, 0xC7, 0x0A, 0xC5, 0x6D, 0xD0, 0xC2, 0xD4, + 0xF5, 0xA1, 0x5E, 0x45, 0x28, 0x54, 0x1D, 0x87, 0xC8, 0x83, 0xAF, 0x9E, 0xB7, 0xC7, 0x4D, 0x48, + 0x3B, 0x49, 0x23, 0x8B, 0x23, 0x6A, 0x2D, 0xD6, 0x30, 0xAD, 0xD3, 0xFA, 0x35, 0x67, 0xF0, 0x0D, + 0x3A, 0xDC, 0x42, 0x57, 0xBE, 0xE6, 0x5B, 0x26, 0x0B, 0x30, 0x45, 0x7E, 0x71, 0x5D, 0x82, 0xE7, + 0x40, 0x45, 0x58, 0xBB, 0xF5, 0x07, 0xEC, 0x36, 0x47, 0xF7, 0x98, 0x05, 0x70, 0x83, 0x17, 0x9D, + 0xDD, 0x4A, 0x4A, 0xB7, 0xB5, 0xBC, 0x8B, 0xF5, 0x08, 0x47, 0x74, 0xF3, 0x0F, 0x3C, 0xB0, 0xC7, + 0x30, 0x88, 0xCF, 0xA2, 0xE1, 0xC3, 0x13, 0x52, 0x20, 0x2D, 0xAD, 0xB3, 0x99, 0x37, 0x71, 0x91, + 0xBB, 0x3F, 0x31, 0xAC, 0xEC, 0xB8, 0x2A, 0x84, 0x12, 0x34, 0x84, 0xE5, 0xBF, 0x47, 0x94, 0xD6, + 0x9A, 0x1F, 0xEB, 0x34, 0xAF, 0xDA, 0x93, 0x5D, 0x22, 0x88, 0x27, 0x1A, 0x04, 0x13, 0xAA, 0x06, + 0x52, 0x8C, 0x44, 0xCB, 0xCC, 0x70, 0x7A, 0xBF, 0xC3, 0x3D, 0x21, 0x71, 0x99, 0x4F, 0x06, 0x42, + 0x8B, 0x7F, 0xDA, 0xBC, 0xAF, 0x7C, 0x24, 0x94, 0x3F, 0xC9, 0xB9, 0xF0, 0xFB, 0x9C, 0xFB, 0x94, + 0xFC, 0x7F, 0xA0, 0x2F, 0x20, 0x4D, 0x57, 0x06, 0xDB, 0xA8, 0xC4, 0xBD, 0x02, 0x6C, 0xDD, 0x00, + 0x8C, 0x84, 0xEF, 0x63, 0xDB, 0x45, 0x34, 0x21, 0x69, 0x73, 0x53, 0x22, 0xD3, 0x61, 0xA6, 0x7A, + 0xDE, 0xC1, 0x66, 0xFD, 0x3B, 0x95, 0x13, 0x76, 0x06, 0xE4, 0x76, 0x0E, 0x63, 0xF2, 0x66, 0x56, + 0xE3, 0x80, 0x55, 0x57, 0xF3, 0x88, 0xA2, 0x5E, 0x84, 0x29, 0xFD, 0x44, 0x78, 0xA9, 0xF0, 0x3A, + 0xF9, 0xE7, 0xDD, 0x66, 0xE1, 0x48, 0xA4, 0xD7, 0x15, 0x06, 0x47, 0xBA, 0x1E, 0x70, 0xA0, 0xA2, + 0xBC, 0x79, 0xCF, 0x9B, 0xA6, 0x61, 0x95, 0x4F, 0xF8, 0x46, 0xA7, 0xD5, 0xB5, 0x5F, 0x66, 0xDD, + 0xE2, 0x5A, 0x8B, 0x29, 0xBA, 0x02, 0xC8, 0x1A, 0x17, 0xFD, 0x72, 0x45, 0xED, 0x63, 0x46, 0x64, + 0x5E, 0xC9, 0x24, 0x8D, 0x91, 0x38, 0xD1, 0xEF, 0xDF, 0x82, 0x09, 0xB0, 0x5B, 0x8C, 0x43, 0x5F, + 0xF9, 0x05, 0x34, 0x1E, 0x2B, 0x4D, 0xA8, 0xC3, 0xE5, 0x9A, 0xD5, 0x95, 0x1B, 0xC0, 0xB9, 0x30, + 0x55, 0xB1, 0xEF, 0x53, 0xD2, 0x86, 0x65, 0x96, 0xD1, 0x3C, 0x75, 0x9E, 0x43, 0xED, 0x72, 0x92, + 0x5F, 0xC3, 0xF8, 0x4C, 0x14, 0xA7, 0x77, 0x22, 0x48, 0x5E, 0xD0, 0x02, 0x32, 0xB4, 0x5F, 0xA9, + 0xCD, 0x9C, 0xF6, 0x46, 0x60, 0xEF, 0x4D, 0x14, 0x84, 0x6E, 0xC5, 0x2C, 0xA6, 0xB2, 0xFB, 0x38, + 0xD1, 0x0C, 0xB2, 0x87, 0xE8, 0x64, 0x1E, 0xFD, 0xC4, 0x28, 0x08, 0x37, 0x61, 0x85, 0x11, 0x44, + 0x76, 0xC9, 0x9F, 0xAD, 0x6D, 0xBC, 0xC0, 0xC8, 0x02, 0xC8, 0xDA, 0x22, 0x1D, 0xB3, 0x54, 0x5F, + 0x38, 0x0D, 0x1D, 0xC0, 0x78, 0x46, 0x7C, 0x46, 0x05, 0xC1, 0x51, 0x9A, 0xF7, 0x7E, 0x51, 0x75, + 0x32, 0xD6, 0xB1, 0x7E, 0x8B, 0x3A, 0xB9, 0xA8, 0x12, 0xAF, 0xF8, 0x20, 0x69, 0xED, 0x37, 0xB4, + 0xD2, 0x7D, 0x7C, 0x08, 0xE4, 0x74, 0xD8, 0x18, 0x2B, 0x6E, 0x65, 0x21, 0xC4, 0x8C, 0xF0, 0xB2, + 0x1A, 0x7D, 0xDD, 0xA5, 0xE9, 0xC3, 0x88, 0xEE, 0x7E, 0x80, 0xE3, 0x4B, 0x3A, 0x56, 0x3D, 0x4B, + 0x75, 0x62, 0xE1, 0xCE, 0xB6, 0xD5, 0xF1, 0xFC, 0x0C, 0x0A, 0x66, 0x10, 0xD2, 0xC0, 0xF3, 0xD3, + 0xCA, 0xFE, 0xD6, 0x73, 0xE4, 0x21, 0xDA, 0xED, 0xE4, 0xE4, 0x5A, 0xAC, 0x31, 0x6D, 0x84, 0x8E, + 0x24, 0x56, 0x6B, 0x09, 0x14, 0x09, 0x81, 0xD6, 0xC6, 0x92, 0x2B, 0xE5, 0x2F, 0x61, 0xCE, 0xD3, + 0xBD, 0x31, 0x10, 0x56, 0x4C, 0x68, 0x18, 0xA2, 0x4E, 0xBF, 0x22, 0x71, 0x77, 0x4A, 0xEC, 0x3F, + 0x8A, 0x10, 0xF9, 0x62, 0x7B, 0x4F, 0x7E, 0xE3, 0x16, 0x23, 0x3C, 0x4A, 0x7B, 0xD9, 0xCC, 0xA1, + 0x13, 0x09, 0x31, 0xD8, 0xD1, 0x23, 0xC4, 0xAD, 0x48, 0xD6, 0xC7, 0xCF, 0xB6, 0xE2, 0x5E, 0x53, + 0xAF, 0x45, 0xF4, 0xE4, 0x82, 0xDC, 0xB3, 0x5D, 0x19, 0x4A, 0x71, 0xBE, 0x75, 0x1D, 0x82, 0x9C, + 0xCD, 0x1F, 0x1E, 0xCE, 0xE1, 0xB6, 0x94, 0xED, 0x9A, 0x3A, 0x1A, 0x66, 0xFF, 0x5C, 0x43, 0x7D, + 0x51, 0x46, 0x09, 0xBB, 0xD0, 0x5D, 0x1A, 0x81, 0x98, 0x9A, 0xAC, 0x74, 0x94, 0xD3, 0x05, 0x55, + 0xE1, 0xE4, 0x2A, 0x43, 0xCC, 0xC8, 0x2C, 0x10, 0xA7, 0xE8, 0xAD, 0x5F, 0x02, 0xDF, 0x3B, 0x10, + 0x33, 0x43, 0x8A, 0x92, 0xF9, 0xCF, 0x12, 0x04, 0x60, 0xCD, 0xA0, 0x30, 0xA9, 0xE8, 0x32, 0x30, + 0x80, 0x8B, 0xF2, 0x09, 0xA4, 0x91, 0xFA, 0x3B, 0xBD, 0x1D, 0x54, 0xFD, 0xF8, 0xCF, 0x74, 0x70, + 0x50, 0x9B, 0x8D, 0x40, 0xBD, 0xC7, 0x3D, 0x4F, 0x03, 0x7B, 0x63, 0x32, 0xCE, 0x8B, 0x5B, 0x7C, + 0x9A, 0xE0, 0x3A, 0x37, 0x38, 0xCA, 0x31, 0x21, 0xDB, 0x4F, 0xF6, 0xF0, 0xDB, 0x4E, 0xE5, 0xDC, + 0x69, 0x4B, 0xAE, 0x28, 0x01, 0xF2, 0x46, 0x38, 0x6A, 0x9A, 0x50, 0x2D, 0xF4, 0x36, 0x5D, 0xEF, + 0x25, 0xB1, 0x31, 0xCA, 0x58, 0x5E, 0x4B, 0xE6, 0xAC, 0xCF, 0x0C, 0x20, 0x84, 0x7F, 0xF5, 0xC1, + 0x1A, 0xE5, 0x94, 0xC3, 0x3D, 0x77, 0x8E, 0xA3, 0x9B, 0xAF, 0x96, 0xBF, 0xD1, 0xEC, 0x35, 0x17, + 0x15, 0xDF, 0x2B, 0x00, 0xCD, 0x2C, 0xDB, 0xD3, 0x31, 0x8A, 0x6D, 0xE0, 0xB3, 0x1F, 0x71, 0xB4, + 0xA4, 0xCA, 0xFA, 0x40, 0xEB, 0x99, 0x4C, 0xFB, 0xFE, 0x9D, 0xBA, 0x26, 0x0F, 0x1B, 0x6D, 0xE6, + 0xB6, 0x2C, 0xAD, 0xF4, 0xD8, 0x12, 0xC0, 0xA3, 0xA4, 0x65, 0x10, 0x1B, 0xCD, 0xFD, 0x0A, 0xB0, + 0x52, 0x71, 0x56, 0xD4, 0x01, 0x49, 0xC9, 0x68, 0x06, 0xA1, 0xD3, 0x61, 0x8A, 0xC1, 0x07, 0x1B, + 0x06, 0x48, 0x78, 0x1B, 0x96, 0xCB, 0x7B, 0xC5, 0xF4, 0x8B, 0x27, 0x93, 0xF1, 0x10, 0x40, 0xB3, + 0x36, 0xA3, 0xA8, 0x19, 0xF3, 0x1B, 0x1B, 0xA4, 0xCD, 0x19, 0x18, 0x25, 0x7C, 0x24, 0xAC, 0x05, + 0xD1, 0xB2, 0xA1, 0x1E, 0x0B, 0xB3, 0xDA, 0x82, 0x3E, 0x78, 0x87, 0x12, 0x8F, 0xE6, 0xB9, 0x59, + 0x02, 0xDC, 0x15, 0x31, 0xA3, 0xAE, 0x22, 0x2F, 0xB7, 0x60, 0x08, 0x42, 0xA0, 0x4B, 0x94, 0xA1, + 0x1A, 0xD9, 0x32, 0x40, 0x2C, 0x33, 0x5A, 0x62, 0xB3, 0xDB, 0x9C, 0x04, 0x3B, 0xCE, 0x40, 0xCD, + 0x3C, 0x29, 0xDB, 0x1C, 0x98, 0xC7, 0x7B, 0x09, 0x65, 0x91, 0xCD, 0xB9, 0x71, 0x80, 0xF2, 0x14, + 0x90, 0x27, 0xA5, 0xC7, 0x16, 0xBB, 0xC8, 0x6D, 0x79, 0x0F, 0xC7, 0x06, 0x4F, 0xFD, 0xEF, 0x3D, + 0x7E, 0xA9, 0x1A, 0x20, 0x4A, 0x94, 0x3F, 0x84, 0xA1, 0x97, 0xE1, 0x99, 0xF5, 0x9E, 0xB2, 0x46, + 0x23, 0xC3, 0x48, 0x46, 0xC0, 0x2C, 0x7D, 0x64, 0x45, 0x7B, 0xA0, 0xBF, 0x5F, 0x14, 0xBC, 0xB2, + 0x17, 0x87, 0x68, 0x5C, 0x17, 0xCE, 0xCA, 0xEA, 0x73, 0x3C, 0xAE, 0x6C, 0x8C, 0x4A, 0x2C, 0xFB, + 0x77, 0x52, 0xE7, 0xA1, 0xFF, 0x6C, 0x23, 0x05, 0x1E, 0x69, 0x22, 0xF1, 0xDA, 0x6B, 0xB6, 0x01, + 0x44, 0xDE, 0xEB, 0x80, 0xB7, 0x84, 0x5B, 0xC7, 0xEA, 0x59, 0x5B, 0x3F, 0x23, 0x7E, 0x10, 0x00, + 0x27, 0x5C, 0x6A, 0x7B, 0xEB, 0xFF, 0xDF, 0x82, 0xEE, 0x85, 0x6C, 0xA5, 0x1A, 0xBF, 0xEB, 0x64, + 0xBB, 0x10, 0x46, 0x40, 0x51, 0x29, 0x2C, 0x6A, 0xD2, 0xF5, 0x58, 0x61, 0x5F, 0x77, 0x31, 0xBD, + 0x59, 0x0A, 0x1B, 0xF5, 0xC2, 0xFA, 0x9A, 0xB4, 0x59, 0xF4, 0x0A, 0xD1, 0x68, 0xCC, 0x21, 0x44, + 0xDC, 0x70, 0x80, 0xD1, 0x67, 0xCC, 0x24, 0x22, 0xC0, 0x77, 0x04, 0xED, 0xA3, 0xB4, 0x23, 0xC8, + 0xAD, 0x5E, 0x18, 0x64, 0x57, 0x89, 0x52, 0xDD, 0x25, 0x6C, 0x38, 0xCE, 0x5D, 0x45, 0x42, 0x18, + 0xA3, 0xE2, 0xD8, 0x6E, 0x21, 0x5F, 0xBB, 0x9D, 0xCA, 0x90, 0x57, 0x85, 0x0C, 0xD5, 0x56, 0xC8, + 0x12, 0x39, 0x27, 0x44, 0x77, 0xE6, 0x59, 0xE7, 0x08, 0xB0, 0x4E, 0x80, 0xBD, 0xE3, 0xE6, 0x8B, + 0xE1, 0x4B, 0x6E, 0xCE, 0xA9, 0x5C, 0x8E, 0xF2, 0xE2, 0xFE, 0x18, 0xFB, 0x74, 0xD6, 0x3C, 0x76, + 0xB8, 0xB0, 0x90, 0x00, 0x3A, 0xF4, 0xE4, 0xB7, 0xFD, 0x05, 0xA3, 0x7A, 0xD9, 0xF7, 0x0E, 0x18, + 0x66, 0xBC, 0x9A, 0x47, 0x18, 0x80, 0x4F, 0x4A, 0x6B, 0x9C, 0xF8, 0x48, 0x16, 0x49, 0x3F, 0x21, + 0xB4, 0x20, 0x59, 0x51, 0xDA, 0xD1, 0x4B, 0xE8, 0x5E, 0x48, 0x95, 0x77, 0x0A, 0x82, 0xA1, 0x8F, + 0xD2, 0x77, 0xC9, 0xC5, 0xE2, 0x79, 0x24, 0x87, 0x34, 0x0C, 0x9E, 0x17, 0x6F, 0x7B, 0xEA, 0x14, + 0x79, 0xF6, 0x0C, 0x95, 0x5F, 0x1C, 0x61, 0x01, 0x61, 0x6D, 0xD1, 0xF2, 0x6A, 0xA8, 0x09, 0xAA, + 0x0A, 0x6E, 0xF9, 0x28, 0x69, 0x49, 0x14, 0x60, 0x6D, 0xA3, 0xCF, 0x5E, 0x4C, 0x34, 0x8E, 0xFC, + 0x7E, 0x3E, 0x72, 0x3E, 0x02, 0x78, 0x3D, 0x1B, 0xA4, 0x93, 0x46, 0x39, 0x46, 0x0E, 0xF0, 0xE3, + 0x46, 0xF0, 0x4C, 0x2F, 0xE2, 0x14, 0x93, 0xF0, 0x2A, 0x5B, 0xE8, 0x05, 0xF7, 0x10, 0x3A, 0x6D, + 0x03, 0xA0, 0x5D, 0xF8, 0x5D, 0xD1, 0x4C, 0x58, 0x7B, 0xBF, 0xAB, 0x52, 0xC1, 0x6E, 0x72, 0x1E, + 0x60, 0x8C, 0x33, 0x4E, 0x22, 0xE7, 0x12, 0x51, 0x0B, 0xFE, 0x22, 0xDA, 0x8A, 0x53, 0xA7, 0xC6, + 0x9A, 0x66, 0x92, 0x76, 0x46, 0x3C, 0xC5, 0x72, 0x55, 0x6C, 0xD2, 0x8D, 0xF1, 0xD5, 0x6C, 0x09, + 0xEA, 0x2D, 0x1A, 0xF9, 0x99, 0x5E, 0x65, 0xCC, 0x6D, 0x55, 0x5F, 0x46, 0x66, 0xC3, 0xBB, 0xBE, + 0x1C, 0x53, 0x40, 0x3B, 0xE9, 0x15, 0x6C, 0xD6, 0x94, 0x8C, 0x5D, 0xB4, 0x4A, 0xDC, 0x2F, 0x2F, + 0xC1, 0xA8, 0xE1, 0xDF, 0x7A, 0xB5, 0x6D, 0xE2, 0xF8, 0xDB, 0xAA, 0x5D, 0x3D, 0x80, 0x5D, 0x33, + 0x6F, 0xCD, 0x5A, 0x84, 0xBC, 0x2D, 0x6E, 0x28, 0x97, 0x07, 0xA6, 0xF1, 0x0B, 0x22, 0x23, 0x58, + 0xDF, 0x50, 0x15, 0x73, 0xD6, 0x75, 0x63, 0xB6, 0x0F, 0xD8, 0x75, 0x9B, 0xF9, 0x9D, 0xBF, 0xE6, + 0xAF, 0xF8, 0xBF, 0xB4, 0x3A, 0xD4, 0x02, 0x3B, 0x8A, 0x4D, 0xF6, 0x44, 0x0E, 0x7F, 0x2B, 0xDB, + 0x9C, 0xAC, 0xD6, 0xB8, 0xC5, 0xB5, 0xEF, 0x1B, 0x67, 0xB0, 0x10, 0xCC, 0x1E, 0x24, 0xD4, 0x05, + 0x06, 0x6D, 0x3A, 0xFE, 0x95, 0x4C, 0x00, 0x8A, 0xD2, 0x53, 0x1B, 0x7A, 0xDE, 0xA0, 0x9F, 0x2D, + 0x10, 0x43, 0x2D, 0xA3, 0x8E, 0x66, 0x36, 0x27, 0x77, 0x05, 0x26, 0x78, 0x21, 0x09, 0x18, 0xD0, + 0x2E, 0x86, 0x1E, 0x56, 0x3B, 0x71, 0x3A, 0x46, 0x24, 0x7C, 0x90, 0x1E, 0x42, 0x36, 0x11, 0xA1, + 0x7C, 0x04, 0x80, 0x42, 0x0F, 0xA8, 0x4E, 0x07, 0xA1, 0x7B, 0x55, 0x5F, 0xA8, 0x8A, 0x1D, 0x36, + 0x9C, 0x16, 0xBD, 0xE0, 0x63, 0x0A, 0xE3, 0xC5, 0xF9, 0x55, 0xA4, 0xE9, 0x75, 0x7D, 0xD5, 0x82, + 0x32, 0x1E, 0x6B, 0x05, 0xE4, 0xF9, 0x8A, 0x8C, 0x18, 0x0E, 0xA0, 0xDF, 0x23, 0x4D, 0xA8, 0x4E, + 0xF0, 0x85, 0xFF, 0x04, 0xC5, 0xFE, 0x1E, 0x8A, 0x3F, 0xBF, 0x54, 0x05, 0x82, 0x8A, 0x0C, 0xDF, + 0xCA, 0x0A, 0xD0, 0x43, 0x76, 0xE5, 0x49, 0x55, 0x36, 0x24, 0x6F, 0x2F, 0x20, 0x58, 0x3A, 0xFE, + 0x62, 0x3A, 0x11, 0xAA, 0x2F, 0xB2, 0x25, 0x6F, 0x0B, 0x9D, 0xD8, 0xCC, 0xC5, 0x26, 0x16, 0x2E, + 0x74, 0x56, 0xBE, 0x99, 0xF4, 0xE7, 0x90, 0x88, 0x65, 0x1E, 0x6C, 0xAA, 0xB4, 0x2C, 0xCF, 0x12, + 0x63, 0x86, 0x8E, 0x9C, 0xF5, 0x75, 0x5A, 0x71, 0xBF, 0xFB, 0x54, 0xF3, 0x86, 0x61, 0xC5, 0x59, + 0xB4, 0xD5, 0x8E, 0x5D, 0x91, 0xA0, 0xB0, 0x9B, 0xB1, 0x95, 0xCE, 0x45, 0x0C, 0x4A, 0xFC, 0xE0, + 0x56, 0x73, 0x96, 0xC1, 0xAA, 0x0A, 0x65, 0x42, 0x42, 0xC1, 0xC7, 0x2D, 0x6E, 0xC8, 0x4A, 0x7F, + 0x40, 0x53, 0x0C, 0x7A, 0x99, 0x96, 0x59, 0xFA, 0xEC, 0xAD, 0xA1, 0xF0, 0xAB, 0xFE, 0xB6, 0x58, + 0x49, 0x65, 0xF4, 0x29, 0x2A, 0x21, 0x42, 0x93, 0x0A, 0xED, 0x38, 0xC0, 0x33, 0xFD, 0xCF, 0x8E, + 0xC1, 0xEC, 0x3A, 0xF9, 0x1F, 0xEA, 0x8F, 0xA2, 0xEA, 0xAE, 0xC4, 0xE7, 0x43, 0xCB, 0x53, 0xF1, + 0x77, 0xC9, 0x6C, 0x61, 0x35, 0xE2, 0xED, 0x25, 0x68, 0xF6, 0x8E, 0x06, 0xD6, 0x41, 0x87, 0x58, + 0x8A, 0xE4, 0x5F, 0x80, 0x59, 0xC7, 0x21, 0xAC, 0xC1, 0x95, 0xC8, 0xBA, 0xF9, 0x84, 0x1F, 0x70, + 0x15, 0x1C, 0xB1, 0xF1, 0x2B, 0xB4, 0xB7, 0xA0, 0x4B, 0xE3, 0xB3, 0xD4, 0x3C, 0x9C, 0x01, 0xB2, + 0x4A, 0xE5, 0x47, 0x39, 0x10, 0x32, 0xE0, 0x0E, 0x1C, 0xE9, 0x3E, 0x2E, 0xDD, 0x12, 0x2C, 0xDF, + 0xB7, 0x47, 0xE8, 0x88, 0x53, 0x28, 0xF2, 0xC6, 0x11, 0x12, 0x15, 0x4A, 0x60, 0x14, 0xA4, 0x78, + 0x54, 0x8E, 0x6A, 0x77, 0xD6, 0x74, 0xC2, 0xCD, 0x4B, 0xF9, 0xC2, 0x84, 0xE8, 0xD6, 0xED, 0x4D, + 0xB3, 0x0C, 0x32, 0x39, 0xCF, 0xB9, 0xF9, 0x0B, 0xC3, 0x52, 0xF5, 0x6E, 0x9A, 0x38, 0x84, 0xED, + 0x0D, 0x83, 0xFA, 0x83, 0x2D, 0xF4, 0xB3, 0xEE, 0x71, 0xE0, 0x47, 0x48, 0xE6, 0x1A, 0x0B, 0xD9, + 0x54, 0x74, 0xB8, 0x39, 0xA1, 0x4C, 0xC7, 0x3C, 0x52, 0x02, 0x07, 0x61, 0x12, 0x1B, 0x49, 0x0B, + 0x7D, 0x08, 0xAA, 0xEA, 0xB0, 0x3A, 0x05, 0x65, 0x9A, 0xEA, 0x68, 0x0C, 0x5B, 0xA6, 0x37, 0xC6, + 0x5F, 0x10, 0x7D, 0xC8, 0xAE, 0xCA, 0x65, 0x1F, 0x16, 0x80, 0x38, 0xF1, 0xB7, 0xB5, 0xDB, 0x1D, + 0x37, 0x5A, 0x1D, 0xEB, 0x7B, 0x2C, 0xA1, 0x7B, 0x72, 0xCE, 0x0D, 0x34, 0xB4, 0x17, 0x23, 0x52, + 0x8B, 0x3A, 0xD6, 0xEC, 0xE5, 0x8D, 0x23, 0x6A, 0xCF, 0x34, 0xDE, 0x02, 0x5A, 0xA4, 0x54, 0xFF, + 0x85, 0x85, 0x3E, 0x33, 0x87, 0xF9, 0x27, 0x59, 0xE2, 0x32, 0xAB, 0x8D, 0xBA, 0x8A, 0x92, 0xEB, + 0x5D, 0xA7, 0xF6, 0x6A, 0xDF, 0x32, 0xAD, 0xAC, 0x70, 0xCF, 0x91, 0xA9, 0x8E, 0x4C, 0x39, 0x71, + 0x4C, 0x1B, 0xBF, 0xD1, 0xD0, 0x68, 0x19, 0x9C, 0x8A, 0x7B, 0x57, 0x52, 0x40, 0xCE, 0xCC, 0x86, + 0xB7, 0x0E, 0x3D, 0x5E, 0xAD, 0xD0, 0x2B, 0xD4, 0x58, 0x5C, 0x5B, 0xD8, 0x00, 0x7F, 0x42, 0x99, + 0x84, 0x5D, 0x2D, 0x86, 0x40, 0x10, 0x35, 0x15, 0x05, 0x67, 0xDE, 0x22, 0x6C, 0xB4, 0x5C, 0x7B, + 0xCA, 0xDF, 0xF4, 0x1D, 0xD2, 0xCB, 0x34, 0x02, 0x6C, 0x22, 0x10, 0x4F, 0x7F, 0xDF, 0x18, 0xFF, + 0x5A, 0x81, 0x4C, 0xAC, 0xF7, 0xF3, 0xF1, 0x5D, 0xBA, 0x72, 0x36, 0x26, 0x88, 0xAE, 0xCA, 0xE0, + 0x79, 0x84, 0x68, 0x86, 0xCE, 0x35, 0xAF, 0x27, 0xB4, 0x21, 0xFD, 0x05, 0xB1, 0x38, 0x17, 0x7D, + 0x9B, 0x5A, 0x12, 0x29, 0x76, 0xE5, 0xA0, 0x39, 0x0B, 0xAD, 0x4C, 0x33, 0xCB, 0x45, 0x59, 0x82, + 0xB7, 0x03, 0xD2, 0x1A, 0xF7, 0x2F, 0x54, 0x43, 0x92, 0xC9, 0x8B, 0x6F, 0x6C, 0x6C, 0x1B, 0x10, + 0xEE, 0x97, 0x38, 0xA5, 0x8B, 0x16, 0xDE, 0xFC, 0xDA, 0x83, 0x4B, 0x39, 0x79, 0x17, 0xB7, 0x5A, + 0x59, 0x01, 0x11, 0xC0, 0xC6, 0x36, 0xD5, 0xBA, 0xB1, 0x46, 0x9E, 0x6B, 0xA1, 0xCB, 0x96, 0x7E, + 0x56, 0x91, 0x87, 0x68, 0x59, 0x8E, 0xCF, 0xB5, 0x58, 0x24, 0x2C, 0xD9, 0x0A, 0x06, 0x25, 0xCB, + 0x8C, 0xE6, 0x02, 0xE3, 0x5A, 0x19, 0x4D, 0x8F, 0x43, 0x5B, 0x40, 0x3F, 0x7D, 0x50, 0x24, 0x90, + 0x71, 0x3E, 0x88, 0x96, 0x3C, 0xCE, 0x2C, 0x80, 0x35, 0x68, 0x3E, 0x21, 0x67, 0x8A, 0x03, 0x68, + 0x49, 0x6B, 0xFA, 0xE2, 0x5A, 0xC7, 0xFF, 0x9C, 0xDF, 0x0D, 0xD9, 0xB5, 0x12, 0x07, 0x35, 0x7B, + 0x35, 0xDC, 0xF7, 0x12, 0x55, 0x71, 0x8A, 0x9F, 0x68, 0x66, 0x2A, 0x72, 0x55, 0x14, 0x82, 0xE2, + 0xBC, 0x3A, 0x39, 0xA7, 0x91, 0xA9, 0x91, 0xC8, 0x2B, 0x5F, 0x0A, 0x09, 0xFD, 0xE0, 0x6B, 0x58, + 0x85, 0x58, 0x1D, 0xCD, 0xEA, 0xAE, 0xBA, 0xA5, 0x49, 0xFF, 0x69, 0x4A, 0x10, 0xDD, 0x5A, 0xE0, + 0x0E, 0xD3, 0x9C, 0x0B, 0xD8, 0x28, 0x2E, 0xCA, 0x8E, 0x9F, 0x29, 0x84, 0xC8, 0xCA, 0x47, 0x79, + 0xB9, 0xCC, 0x71, 0xC6, 0xE1, 0xC1, 0x4D, 0x15, 0xB6, 0x1F, 0x92, 0x13, 0x2C, 0x83, 0xBE, 0x0D, + 0x03, 0x0A, 0x7C, 0x02, 0x7C, 0x2C, 0xFA, 0x8E, 0xC8, 0x23, 0xE1, 0xFD, 0x83, 0xDC, 0x61, 0xDB, + 0x1C, 0xE4, 0x3F, 0xE8, 0xA9, 0x1C, 0x55, 0x1E, 0xB2, 0xF1, 0x47, 0x6C, 0x5A, 0xD8, 0xD9, 0xD4, + 0xA8, 0xBF, 0x4B, 0xF9, 0x0A, 0xD5, 0xBF, 0x1D, 0x88, 0x30, 0x12, 0x80, 0x72, 0x49, 0x6C, 0x91, + 0x70, 0x6A, 0xB7, 0x4D, 0x86, 0x34, 0x8F, 0x57, 0x1A, 0x6A, 0x16, 0x7B, 0xA5, 0x5D, 0x3C, 0x74, + 0x8E, 0x03, 0x1D, 0x53, 0xD6, 0x1C, 0x75, 0x83, 0x2C, 0xF7, 0x5E, 0xF6, 0xE0, 0xC9, 0x25, 0x11, + 0x9F, 0x98, 0x73, 0xD2, 0xBE, 0x50, 0x56, 0xD6, 0x73, 0x38, 0xC8, 0x30, 0x5A, 0xB5, 0xF6, 0x67, + 0x37, 0x75, 0x7E, 0x99, 0x71, 0xC7, 0x30, 0x26, 0x0D, 0x43, 0xA2, 0x0B, 0xF0, 0xC2, 0xCC, 0x38, + 0xDF, 0x0F, 0x37, 0x25, 0xA0, 0x4F, 0x18, 0x5A, 0x40, 0x75, 0x2D, 0xFC, 0x52, 0xFF, 0x37, 0xD5, + 0x38, 0x06, 0xC6, 0x62, 0x13, 0xA0, 0x8E, 0x7A, 0xFA, 0xDD, 0xB9, 0x25, 0xBE, 0xBC, 0x1F, 0x02, + 0x4C, 0x56, 0xA1, 0xBA, 0x08, 0xBB, 0x65, 0xAE, 0xAC, 0x14, 0x4E, 0x65, 0xD7, 0xD1, 0x99, 0xFF, + 0x14, 0x33, 0x9F, 0x18, 0x1D, 0x54, 0x70, 0x6F, 0xBC, 0x85, 0xB4, 0x49, 0x82, 0x4C, 0x0A, 0xA6, + 0xE8, 0x10, 0x61, 0x8F, 0xED, 0xFD, 0x7F, 0x10, 0xAA, 0xAC, 0x13, 0xB5, 0xE2, 0x5D, 0xF3, 0x69, + 0x2B, 0xC3, 0xE1, 0xC2, 0x89, 0x9A, 0x46, 0xF0, 0x97, 0x34, 0xFC, 0x93, 0x31, 0x45, 0xE9, 0x7A, + 0xD4, 0x46, 0x1A, 0x31, 0xFF, 0x65, 0x39, 0xAE, 0xCE, 0xC5, 0x40, 0x2F, 0xD0, 0xCB, 0x1E, 0xC6, + 0x86, 0xDC, 0x2F, 0x72, 0x34, 0x35, 0x28, 0xAD, 0x96, 0xC3, 0xBE, 0xE4, 0xC8, 0xA5, 0xB6, 0x6B, + 0xBD, 0xFB, 0x9B, 0xE5, 0x16, 0x01, 0x4A, 0x55, 0xA2, 0xB0, 0xE8, 0x66, 0x4A, 0xC1, 0xE3, 0xC0, + 0xB9, 0x87, 0xF4, 0xD6, 0x8C, 0xF4, 0x61, 0x42, 0xA4, 0xBF, 0x73, 0x03, 0x67, 0xBD, 0x2F, 0x30, + 0x6E, 0x97, 0x45, 0x0F, 0xC6, 0xBD, 0xCA, 0x2E, 0x69, 0x72, 0x41, 0x07, 0x38, 0x74, 0x18, 0xB1, + 0xCB, 0x5C, 0xD3, 0xC2, 0x1D, 0xB7, 0xF2, 0xAF, 0xEC, 0x00, 0xCD, 0x4F, 0x6F, 0xDE, 0xB2, 0xAC, + 0x44, 0x4C, 0x1A, 0x56, 0xC3, 0x93, 0x21, 0x57, 0x8C, 0x6B, 0x1C, 0xD7, 0xF9, 0xC7, 0xC0, 0xA9, + 0xF7, 0xE4, 0xA3, 0xD8, 0x58, 0x9B, 0x35, 0xE6, 0x00, 0x7C, 0xE2, 0x12, 0xD0, 0x53, 0x61, 0x1F, + 0xC6, 0xA5, 0x81, 0x7A, 0x52, 0xEF, 0x09, 0x36, 0x1A, 0x62, 0x3C, 0x92, 0xD2, 0x65, 0x43, 0xF6, + 0xDF, 0x0B, 0x89, 0x7E, 0xC6, 0xB9, 0x47, 0xF4, 0x52, 0x14, 0x0C, 0x44, 0x4D, 0x23, 0x55, 0x6F, + 0x80, 0xC2, 0xBE, 0xC5, 0x59, 0xF8, 0xB5, 0x27, 0xE6, 0xE8, 0xF0, 0x32, 0x91, 0x3A, 0x59, 0x2B, + 0x1D, 0xF9, 0xAC, 0xF9, 0x2E, 0xF3, 0xB9, 0x36, 0x8C, 0x1A, 0x5D, 0x92, 0x33, 0xEA, 0xA6, 0xAF, + 0x71, 0x24, 0xE2, 0x7F, 0x18, 0xB1, 0x23, 0x3C, 0x53, 0xF3, 0xCC, 0x5D, 0xD4, 0x2D, 0x2B, 0x7A, + 0xF8, 0x94, 0x04, 0xC0, 0x8C, 0x65, 0x4D, 0x3A, 0xFA, 0xCF, 0xF9, 0x07, 0xC2, 0xD7, 0x75, 0x87, + 0x47, 0x9E, 0x6E, 0xA0, 0x79, 0x81, 0x6E, 0x03, 0xC7, 0xD2, 0x75, 0xF6, 0xC3, 0x85, 0x22, 0x28, + 0x1B, 0x39, 0x63, 0xCC, 0x12, 0x7E, 0x4A, 0xC3, 0x2A, 0x45, 0x85, 0xA9, 0x54, 0xDF, 0xB2, 0x33, + 0xEF, 0x76, 0x25, 0x31, 0xC9, 0xCD, 0xDA, 0x14, 0xE7, 0xD8, 0x4D, 0x18, 0xCE, 0xAB, 0xE7, 0x85, + 0xDD, 0x95, 0x8D, 0x36, 0xA1, 0x18, 0x87, 0x5E, 0xB6, 0x75, 0x2F, 0x3B, 0x97, 0x09, 0x18, 0x47, + 0xC8, 0x90, 0x37, 0xA3, 0xB2, 0xD2, 0x09, 0x3C, 0x5E, 0x6C, 0x2E, 0x72, 0x38, 0x08, 0x24, 0x99, + 0x90, 0xD0, 0x86, 0xC7, 0xD3, 0xFB, 0x4E, 0xA2, 0xDF, 0xC7, 0x26, 0x4D, 0x8E, 0x81, 0x98, 0x19, + 0x15, 0xD0, 0x4C, 0xB8, 0x44, 0xF7, 0x53, 0x1C, 0x0F, 0xAF, 0x78, 0x4C, 0x20, 0xB8, 0xCC, 0xBB, + 0x20, 0x60, 0xEC, 0x55, 0x70, 0xBD, 0xE9, 0x02, 0x63, 0x9F, 0x1F, 0xA7, 0xD5, 0x27, 0x18, 0x33, + 0x29, 0xA8, 0x33, 0x6E, 0xCB, 0x80, 0x40, 0x2D, 0x52, 0xDF, 0x6C, 0x78, 0x8F, 0xA6, 0x1D, 0xCF, + 0xE8, 0xB9, 0x54, 0x6B +}; + +uint8 Module_79C0768D657977D697E10BAD956CCED1_Key[16] = +{ + 0xAE, 0x25, 0xBC, 0x51, 0x06, 0x3B, 0x77, 0xBD, 0x36, 0x3C, 0x3E, 0xFE, 0x0F, 0xC1, 0x73, 0xF9 +}; + +#endif diff --git a/src/server/game/Warden/Warden.cpp b/src/server/game/Warden/Warden.cpp new file mode 100644 index 000000000..3d625df63 --- /dev/null +++ b/src/server/game/Warden/Warden.cpp @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "Common.h" +#include "WorldPacket.h" +#include "WorldSession.h" +#include "Log.h" +#include "Opcodes.h" +#include "ByteBuffer.h" +#include +#include +#include "World.h" +#include "Player.h" +#include "Util.h" +#include "Warden.h" +#include "AccountMgr.h" + +Warden::Warden() : _inputCrypto(16), _outputCrypto(16), _checkTimer(10000/*10 sec*/), _clientResponseTimer(0), _dataSent(false), _initialized(false) +{ +} + +Warden::~Warden() +{ + delete[] _module->CompressedData; + delete _module; + _module = NULL; + _initialized = false; +} + +void Warden::SendModuleToClient() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Send module to client"); + + // Create packet structure + WardenModuleTransfer packet; + + uint32 sizeLeft = _module->CompressedSize; + uint32 pos = 0; + uint16 burstSize; + while (sizeLeft > 0) + { + burstSize = sizeLeft < 500 ? sizeLeft : 500; + packet.Command = WARDEN_SMSG_MODULE_CACHE; + packet.DataSize = burstSize; + memcpy(packet.Data, &_module->CompressedData[pos], burstSize); + sizeLeft -= burstSize; + pos += burstSize; + + EncryptData((uint8*)&packet, burstSize + 3); + WorldPacket pkt1(SMSG_WARDEN_DATA, burstSize + 3); + pkt1.append((uint8*)&packet, burstSize + 3); + _session->SendPacket(&pkt1); + } +} + +void Warden::RequestModule() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Request module"); + + // Create packet structure + WardenModuleUse request; + request.Command = WARDEN_SMSG_MODULE_USE; + + memcpy(request.ModuleId, _module->Id, 16); + memcpy(request.ModuleKey, _module->Key, 16); + request.Size = _module->CompressedSize; + + // Encrypt with warden RC4 key. + EncryptData((uint8*)&request, sizeof(WardenModuleUse)); + + WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenModuleUse)); + pkt.append((uint8*)&request, sizeof(WardenModuleUse)); + _session->SendPacket(&pkt); +} + +void Warden::Update() +{ + if (_initialized) + { + uint32 currentTimestamp = getMSTime(); + uint32 diff = currentTimestamp - _previousTimestamp; + _previousTimestamp = currentTimestamp; + + if (_dataSent) + { + uint32 maxClientResponseDelay = sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_RESPONSE_DELAY); + + if (maxClientResponseDelay > 0) + { + // Kick player if client response delays more than set in config + if (_clientResponseTimer > maxClientResponseDelay * IN_MILLISECONDS) + { + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u, latency: %u, IP: %s) exceeded Warden module response delay for more than %s - disconnecting client", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), _session->GetLatency(), _session->GetRemoteAddress().c_str(), + secsToTimeString(maxClientResponseDelay, true).c_str()); + _session->KickPlayer(); + } + else + _clientResponseTimer += diff; + } + } + else + { + if (diff >= _checkTimer) + { + RequestData(); + } + else + _checkTimer -= diff; + } + } +} + +void Warden::DecryptData(uint8* buffer, uint32 length) +{ + _inputCrypto.UpdateData(length, buffer); +} + +void Warden::EncryptData(uint8* buffer, uint32 length) +{ + _outputCrypto.UpdateData(length, buffer); +} + +bool Warden::IsValidCheckSum(uint32 checksum, const uint8* data, const uint16 length) +{ + uint32 newChecksum = BuildChecksum(data, length); + + if (checksum != newChecksum) + { + sLog->outDebug(LOG_FILTER_WARDEN, "CHECKSUM IS NOT VALID"); + return false; + } + else + { + sLog->outDebug(LOG_FILTER_WARDEN, "CHECKSUM IS VALID"); + return true; + } +} + +uint32 Warden::BuildChecksum(const uint8* data, uint32 length) +{ + uint8 hash[20]; + SHA1(data, length, hash); + uint32 checkSum = 0; + for (uint8 i = 0; i < 5; ++i) + checkSum = checkSum ^ *(uint32*)(&hash[0] + i * 4); + + return checkSum; +} + +std::string Warden::Penalty(WardenCheck* check /*= NULL*/) +{ + WardenActions action; + + if (check) + action = check->Action; + else + action = WardenActions(sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_FAIL_ACTION)); + + switch (action) + { + case WARDEN_ACTION_LOG: + return "None"; + break; + case WARDEN_ACTION_KICK: + _session->KickPlayer(); + return "Kick"; + break; + case WARDEN_ACTION_BAN: + { + std::stringstream duration; + duration << sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_BAN_DURATION) << "s"; + std::string accountName; + AccountMgr::GetName(_session->GetAccountId(), accountName); + sWorld->BanAccount(BAN_ACCOUNT, accountName, duration.str(), "Warden Anticheat violation","Server"); + + return "Ban"; + break; + } + default: + return "Undefined"; + break; + } +} + +void WorldSession::HandleWardenDataOpcode(WorldPacket& recvData) +{ + _warden->DecryptData(const_cast(recvData.contents()), recvData.size()); + uint8 opcode; + recvData >> opcode; + sLog->outDebug(LOG_FILTER_WARDEN, "Got packet, opcode %02X, size %u", opcode, recvData.size()); + recvData.hexlike(); + + switch(opcode) + { + case WARDEN_CMSG_MODULE_MISSING: + _warden->SendModuleToClient(); + break; + case WARDEN_CMSG_MODULE_OK: + _warden->RequestHash(); + break; + case WARDEN_CMSG_CHEAT_CHECKS_RESULT: + _warden->HandleData(recvData); + break; + case WARDEN_CMSG_MEM_CHECKS_RESULT: + sLog->outDebug(LOG_FILTER_WARDEN, "NYI WARDEN_CMSG_MEM_CHECKS_RESULT received!"); + break; + case WARDEN_CMSG_HASH_RESULT: + _warden->HandleHashResult(recvData); + _warden->InitializeModule(); + break; + case WARDEN_CMSG_MODULE_FAILED: + sLog->outDebug(LOG_FILTER_WARDEN, "NYI WARDEN_CMSG_MODULE_FAILED received!"); + break; + default: + sLog->outDebug(LOG_FILTER_WARDEN, "Got unknown warden opcode %02X of size %u.", opcode, recvData.size() - 1); + break; + } +} diff --git a/src/server/game/Warden/Warden.h b/src/server/game/Warden/Warden.h new file mode 100644 index 000000000..e06ea7dca --- /dev/null +++ b/src/server/game/Warden/Warden.h @@ -0,0 +1,147 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDEN_BASE_H +#define _WARDEN_BASE_H + +#include +#include "Cryptography/ARC4.h" +#include "Cryptography/BigNumber.h" +#include "ByteBuffer.h" +#include "WardenCheckMgr.h" + +enum WardenOpcodes +{ + // Client->Server + WARDEN_CMSG_MODULE_MISSING = 0, + WARDEN_CMSG_MODULE_OK = 1, + WARDEN_CMSG_CHEAT_CHECKS_RESULT = 2, + WARDEN_CMSG_MEM_CHECKS_RESULT = 3, // only sent if MEM_CHECK bytes doesn't match + WARDEN_CMSG_HASH_RESULT = 4, + WARDEN_CMSG_MODULE_FAILED = 5, // this is sent when client failed to load uploaded module due to cache fail + + // Server->Client + WARDEN_SMSG_MODULE_USE = 0, + WARDEN_SMSG_MODULE_CACHE = 1, + WARDEN_SMSG_CHEAT_CHECKS_REQUEST = 2, + WARDEN_SMSG_MODULE_INITIALIZE = 3, + WARDEN_SMSG_MEM_CHECKS_REQUEST = 4, // byte len; while(!EOF) { byte unk(1); byte index(++); string module(can be 0); int offset; byte len; byte[] bytes_to_compare[len]; } + WARDEN_SMSG_HASH_REQUEST = 5 +}; + +enum WardenCheckType +{ + MEM_CHECK = 0xF3, // 243: byte moduleNameIndex + uint Offset + byte Len (check to ensure memory isn't modified) + PAGE_CHECK_A = 0xB2, // 178: uint Seed + byte[20] SHA1 + uint Addr + byte Len (scans all pages for specified hash) + PAGE_CHECK_B = 0xBF, // 191: uint Seed + byte[20] SHA1 + uint Addr + byte Len (scans only pages starts with MZ+PE headers for specified hash) + MPQ_CHECK = 0x98, // 152: byte fileNameIndex (check to ensure MPQ file isn't modified) + LUA_STR_CHECK = 0x8B, // 139: byte luaNameIndex (check to ensure LUA string isn't used) + DRIVER_CHECK = 0x71, // 113: uint Seed + byte[20] SHA1 + byte driverNameIndex (check to ensure driver isn't loaded) + TIMING_CHECK = 0x57, // 87: empty (check to ensure GetTickCount() isn't detoured) + PROC_CHECK = 0x7E, // 126: uint Seed + byte[20] SHA1 + byte moluleNameIndex + byte procNameIndex + uint Offset + byte Len (check to ensure proc isn't detoured) + MODULE_CHECK = 0xD9, // 217: uint Seed + byte[20] SHA1 (check to ensure module isn't injected) +}; + +#if defined(__GNUC__) +#pragma pack(1) +#else +#pragma pack(push,1) +#endif + +struct WardenModuleUse +{ + uint8 Command; + uint8 ModuleId[16]; + uint8 ModuleKey[16]; + uint32 Size; +}; + +struct WardenModuleTransfer +{ + uint8 Command; + uint16 DataSize; + uint8 Data[500]; +}; + +struct WardenHashRequest +{ + uint8 Command; + uint8 Seed[16]; +}; + +#if defined(__GNUC__) +#pragma pack() +#else +#pragma pack(pop) +#endif + +struct ClientWardenModule +{ + uint8 Id[16]; + uint8 Key[16]; + uint32 CompressedSize; + uint8* CompressedData; +}; + +class WorldSession; + +class Warden +{ + friend class WardenWin; + friend class WardenMac; + + public: + Warden(); + ~Warden(); + + virtual void Init(WorldSession* session, BigNumber* k) = 0; + virtual ClientWardenModule* GetModuleForClient() = 0; + virtual void InitializeModule() = 0; + virtual void RequestHash() = 0; + virtual void HandleHashResult(ByteBuffer &buff) = 0; + virtual void RequestData() = 0; + virtual void HandleData(ByteBuffer &buff) = 0; + + void SendModuleToClient(); + void RequestModule(); + void Update(); + void DecryptData(uint8* buffer, uint32 length); + void EncryptData(uint8* buffer, uint32 length); + + static bool IsValidCheckSum(uint32 checksum, const uint8 *data, const uint16 length); + static uint32 BuildChecksum(const uint8 *data, uint32 length); + + // If no check is passed, the default action from config is executed + std::string Penalty(WardenCheck* check = NULL); + + private: + WorldSession* _session; + uint8 _inputKey[16]; + uint8 _outputKey[16]; + uint8 _seed[16]; + ARC4 _inputCrypto; + ARC4 _outputCrypto; + uint32 _checkTimer; // Timer for sending check requests + uint32 _clientResponseTimer; // Timer for client response delay + bool _dataSent; + uint32 _previousTimestamp; + ClientWardenModule* _module; + bool _initialized; +}; + +#endif diff --git a/src/server/game/Warden/WardenCheckMgr.cpp b/src/server/game/Warden/WardenCheckMgr.cpp new file mode 100644 index 000000000..77332bd30 --- /dev/null +++ b/src/server/game/Warden/WardenCheckMgr.cpp @@ -0,0 +1,196 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "Common.h" +#include "WorldPacket.h" +#include "WorldSession.h" +#include "Log.h" +#include "Database/DatabaseEnv.h" +#include "Util.h" +#include "WardenCheckMgr.h" +#include "Warden.h" + + +WardenCheckMgr::WardenCheckMgr() +{ + InternalDataID = 1; +} + +WardenCheckMgr::~WardenCheckMgr() +{ + for (uint16 i = 0; i < CheckStore.size(); ++i) + delete CheckStore[i]; + + for (CheckResultContainer::iterator itr = CheckResultStore.begin(); itr != CheckResultStore.end(); ++itr) + delete itr->second; +} + +void WardenCheckMgr::LoadWardenChecks() +{ + // Check if Warden is enabled by config before loading anything + if (!sWorld->getBoolConfig(CONFIG_WARDEN_ENABLED)) + { + sLog->outString(">> Warden disabled, loading checks skipped."); + sLog->outString(); + return; + } + + // For reload case + for (uint16 i = 0; i < CheckStore.size(); ++i) + delete CheckStore[i]; + + CheckStore.clear(); + + for (CheckResultContainer::iterator itr = CheckResultStore.begin(); itr != CheckResultStore.end(); ++itr) + delete itr->second; + CheckResultStore.clear(); + + + QueryResult result = WorldDatabase.Query("SELECT MAX(id) FROM warden_checks"); + + if (!result) + { + sLog->outString(">> Loaded 0 Warden checks. DB table `warden_checks` is empty!"); + sLog->outString(); + return; + } + + Field* fields = result->Fetch(); + + uint32 maxCheckId = fields[0].GetUInt32(); + + CheckStore.resize(maxCheckId + 1); + + // 0 1 2 3 4 5 6 + result = WorldDatabase.Query("SELECT id, type, data, result, address, length, str FROM warden_checks ORDER BY id ASC"); + + uint32 count = 0; + do + { + Field* fields = result->Fetch(); + + uint16 id = fields[0].GetUInt16(); + uint8 checkType = fields[1].GetUInt8(); + std::string data = fields[2].GetString(); + std::string checkResult = fields[3].GetString(); + uint32 address = fields[4].GetUInt32(); + uint8 length = fields[5].GetUInt8(); + std::string str = fields[6].GetString(); + + WardenCheck* wardenCheck = new WardenCheck(); + wardenCheck->Type = checkType; + + // Initialize action with default action from config + wardenCheck->Action = WardenActions(sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_FAIL_ACTION)); + + if (checkType == PAGE_CHECK_A || checkType == PAGE_CHECK_B || checkType == DRIVER_CHECK) + { + wardenCheck->Data.SetHexStr(data.c_str()); + int len = data.size() / 2; + + if (wardenCheck->Data.GetNumBytes() < len) + { + uint8 temp[24]; + memset(temp, 0, len); + memcpy(temp, wardenCheck->Data.AsByteArray(), wardenCheck->Data.GetNumBytes()); + std::reverse(temp, temp + len); + wardenCheck->Data.SetBinary((uint8*)temp, len); + } + } + + if (checkType == MEM_CHECK || checkType == MODULE_CHECK) + MemChecksIdPool.push_back(id); + else + OtherChecksIdPool.push_back(id); + + if (checkType == MEM_CHECK || checkType == PAGE_CHECK_A || checkType == PAGE_CHECK_B || checkType == PROC_CHECK) + { + wardenCheck->Address = address; + wardenCheck->Length = length; + } + + // PROC_CHECK support missing + if (checkType == MEM_CHECK || checkType == MPQ_CHECK || checkType == LUA_STR_CHECK || checkType == DRIVER_CHECK || checkType == MODULE_CHECK) + wardenCheck->Str = str; + + CheckStore[id] = wardenCheck; + + if (checkType == MPQ_CHECK || checkType == MEM_CHECK) + { + WardenCheckResult *wr = new WardenCheckResult(); + wr->Result.SetHexStr(checkResult.c_str()); + int len = checkResult.size() / 2; + if (wr->Result.GetNumBytes() < len) + { + uint8 *temp = new uint8[len]; + memset(temp, 0, len); + memcpy(temp, wr->Result.AsByteArray(), wr->Result.GetNumBytes()); + std::reverse(temp, temp + len); + wr->Result.SetBinary((uint8*)temp, len); + delete [] temp; + } + CheckResultStore[id] = wr; + } + + ++count; + } + while (result->NextRow()); + + // Fetch overrides from char db and overwrite default action in CheckStore + QueryResult overrideResult = CharacterDatabase.Query("SELECT wardenId, action FROM warden_action"); + + uint32 overrideCount = 0; + + if(overrideResult) + { + do + { + Field * fields = overrideResult->Fetch(); + + uint16 checkId = fields[0].GetUInt16(); + + // Check if override check ID actually exists in current Warden checks + if (checkId > maxCheckId) + sLog->outError("Warden check action override for invalid check (ID: %u, action: %u), skipped", checkId, fields[1].GetUInt8()); + else + CheckStore[fields[0].GetUInt16()]->Action = WardenActions(fields[1].GetUInt8()); + + ++overrideCount; + } + while (overrideResult->NextRow()); + } + + sLog->outString(">> Loaded %u warden checks and %u action overrides.", count, overrideCount); + sLog->outString(); +} + +WardenCheck* WardenCheckMgr::GetWardenDataById(uint16 Id) +{ + if (Id < CheckStore.size()) + return CheckStore[Id]; + + return NULL; +} + +WardenCheckResult* WardenCheckMgr::GetWardenResultById(uint16 Id) +{ + CheckResultContainer::const_iterator itr = CheckResultStore.find(Id); + if (itr != CheckResultStore.end()) + return itr->second; + return NULL; +} diff --git a/src/server/game/Warden/WardenCheckMgr.h b/src/server/game/Warden/WardenCheckMgr.h new file mode 100644 index 000000000..cbe8460db --- /dev/null +++ b/src/server/game/Warden/WardenCheckMgr.h @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDENCHECKMGR_H +#define _WARDENCHECKMGR_H + +#include +#include "Cryptography/BigNumber.h" + +enum WardenActions +{ + WARDEN_ACTION_LOG, + WARDEN_ACTION_KICK, + WARDEN_ACTION_BAN +}; + +struct WardenCheck +{ + uint8 Type; + BigNumber Data; + uint32 Address; // PROC_CHECK, MEM_CHECK, PAGE_CHECK + uint8 Length; // PROC_CHECK, MEM_CHECK, PAGE_CHECK + std::string Str; // LUA, MPQ, DRIVER + enum WardenActions Action; +}; + +struct WardenCheckResult +{ + BigNumber Result; // MEM_CHECK +}; + +class WardenCheckMgr +{ + friend class ACE_Singleton; + WardenCheckMgr(); + ~WardenCheckMgr(); + + public: + // We have a linear key without any gaps, so we use vector for fast access + typedef std::vector CheckContainer; + typedef std::map CheckResultContainer; + + WardenCheck* GetWardenDataById(uint16 Id); + WardenCheckResult* GetWardenResultById(uint16 Id); + + uint32 InternalDataID; + std::vector MemChecksIdPool; + std::vector OtherChecksIdPool; + + void LoadWardenChecks(); + + private: + CheckContainer CheckStore; + CheckResultContainer CheckResultStore; +}; + +#define sWardenCheckMgr ACE_Singleton::instance() + +#endif diff --git a/src/server/game/Warden/WardenMac.cpp b/src/server/game/Warden/WardenMac.cpp new file mode 100644 index 000000000..f62aa11a3 --- /dev/null +++ b/src/server/game/Warden/WardenMac.cpp @@ -0,0 +1,260 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "Cryptography/WardenKeyGeneration.h" +#include "Common.h" +#include "WorldPacket.h" +#include "WorldSession.h" +#include "Log.h" +#include "Opcodes.h" +#include "ByteBuffer.h" +#include +#include "World.h" +#include "Player.h" +#include "Util.h" +#include "WardenMac.h" +#include "WardenModuleMac.h" + +WardenMac::WardenMac() : Warden() +{ +} + +WardenMac::~WardenMac() +{ +} + +void WardenMac::Init(WorldSession *pClient, BigNumber *K) +{ + _session = pClient; + // Generate Warden Key + SHA1Randx WK(K->AsByteArray(), K->GetNumBytes()); + WK.generate(_inputKey, 16); + WK.generate(_outputKey, 16); + /* + Seed: 4D808D2C77D905C41A6380EC08586AFE (0x05 packet) + Hash: (0x04 packet) + Module MD5: 0DBBF209A27B1E279A9FEC5C168A15F7 + New Client Key: + New Cerver Key: + */ + uint8 mod_seed[16] = { 0x4D, 0x80, 0x8D, 0x2C, 0x77, 0xD9, 0x05, 0xC4, 0x1A, 0x63, 0x80, 0xEC, 0x08, 0x58, 0x6A, 0xFE }; + + memcpy(_seed, mod_seed, 16); + + _inputCrypto.Init(_inputKey); + _outputCrypto.Init(_outputKey); + sLog->outDebug(LOG_FILTER_WARDEN, "Server side warden for client %u initializing...", pClient->GetAccountId()); + sLog->outDebug(LOG_FILTER_WARDEN, "C->S Key: %s", ByteArrayToHexStr(_inputKey, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "S->C Key: %s", ByteArrayToHexStr(_outputKey, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, " Seed: %s", ByteArrayToHexStr(_seed, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "Loading Module..."); + + _module = GetModuleForClient(); + + sLog->outDebug(LOG_FILTER_WARDEN, "Module Key: %s", ByteArrayToHexStr(_module->Key, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "Module ID: %s", ByteArrayToHexStr(_module->Id, 16).c_str()); + RequestModule(); +} + +ClientWardenModule* WardenMac::GetModuleForClient() +{ + ClientWardenModule *mod = new ClientWardenModule; + + uint32 len = sizeof(Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data); + + // data assign + mod->CompressedSize = len; + mod->CompressedData = new uint8[len]; + memcpy(mod->CompressedData, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Data, len); + memcpy(mod->Key, Module_0DBBF209A27B1E279A9FEC5C168A15F7_Key, 16); + + // md5 hash + MD5_CTX ctx; + MD5_Init(&ctx); + MD5_Update(&ctx, mod->CompressedData, len); + MD5_Final((uint8*)&mod->Id, &ctx); + + return mod; +} + +void WardenMac::InitializeModule() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Initialize module"); +} + +void WardenMac::RequestHash() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash"); + + // Create packet structure + WardenHashRequest Request; + Request.Command = WARDEN_SMSG_HASH_REQUEST; + memcpy(Request.Seed, _seed, 16); + + // Encrypt with warden RC4 key. + EncryptData((uint8*)&Request, sizeof(WardenHashRequest)); + + WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenHashRequest)); + pkt.append((uint8*)&Request, sizeof(WardenHashRequest)); + _session->SendPacket(&pkt); +} + +void WardenMac::HandleHashResult(ByteBuffer &buff) +{ + + // test + int keyIn[4]; + + uint8 mod_seed[16] = { 0x4D, 0x80, 0x8D, 0x2C, 0x77, 0xD9, 0x05, 0xC4, 0x1A, 0x63, 0x80, 0xEC, 0x08, 0x58, 0x6A, 0xFE }; + + for(int i = 0; i < 4; ++i) + { + keyIn[i] = *(int*)(&mod_seed[0] + i * 4); + } + + int keyOut[4]; + int keyIn1, keyIn2; + keyOut[0] = keyIn[0]; + keyIn[0] ^= 0xDEADBEEFu; + keyIn1 = keyIn[1]; + keyIn[1] -= 0x35014542u; + keyIn2 = keyIn[2]; + keyIn[2] += 0x5313F22u; + keyIn[3] *= 0x1337F00Du; + keyOut[1] = keyIn1 - 0x6A028A84; + keyOut[2] = keyIn2 + 0xA627E44; + keyOut[3] = 0x1337F00D * keyIn[3]; + // end test + + buff.rpos(buff.wpos()); + + SHA1Hash sha1; + sha1.UpdateData((uint8*)keyIn, 16); + sha1.Finalize(); + + //const uint8 validHash[20] = { 0x56, 0x8C, 0x05, 0x4C, 0x78, 0x1A, 0x97, 0x2A, 0x60, 0x37, 0xA2, 0x29, 0x0C, 0x22, 0xB5, 0x25, 0x71, 0xA0, 0x6F, 0x4E }; + + // Verify key + if (memcmp(buff.contents() + 1, sha1.GetDigest(), 20) != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash reply: failed"); + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u) failed hash reply. Action: %s", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), Penalty().c_str()); + return; + } + + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash reply: succeed"); + + // client 7F96EEFDA5B63D20A4DF8E00CBF48304 + //const uint8 client_key[16] = { 0x7F, 0x96, 0xEE, 0xFD, 0xA5, 0xB6, 0x3D, 0x20, 0xA4, 0xDF, 0x8E, 0x00, 0xCB, 0xF4, 0x83, 0x04 }; + + // server C2B7ADEDFCCCA9C2BFB3F85602BA809B + //const uint8 server_key[16] = { 0xC2, 0xB7, 0xAD, 0xED, 0xFC, 0xCC, 0xA9, 0xC2, 0xBF, 0xB3, 0xF8, 0x56, 0x02, 0xBA, 0x80, 0x9B }; + + // change keys here + memcpy(_inputKey, keyIn, 16); + memcpy(_outputKey, keyOut, 16); + + _inputCrypto.Init(_inputKey); + _outputCrypto.Init(_outputKey); + + _initialized = true; + + _previousTimestamp = getMSTime(); +} + +void WardenMac::RequestData() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Request data"); + + ByteBuffer buff; + buff << uint8(WARDEN_SMSG_CHEAT_CHECKS_REQUEST); + + std::string str = "Test string!"; + + buff << uint8(str.size()); + buff.append(str.c_str(), str.size()); + + buff.hexlike(); + + // Encrypt with warden RC4 key. + EncryptData(const_cast(buff.contents()), buff.size()); + + WorldPacket pkt(SMSG_WARDEN_DATA, buff.size()); + pkt.append(buff); + _session->SendPacket(&pkt); + + _dataSent = true; +} + +void WardenMac::HandleData(ByteBuffer &buff) +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Handle data"); + + _dataSent = false; + _clientResponseTimer = 0; + + //uint16 Length; + //buff >> Length; + //uint32 Checksum; + //buff >> Checksum; + + //if (!IsValidCheckSum(Checksum, buff.contents() + buff.rpos(), Length)) + //{ + // buff.rpos(buff.wpos()); + // if (sWorld->getBoolConfig(CONFIG_BOOL_WARDEN_KICK)) + // Client->KickPlayer(); + // return; + //} + + bool found = false; + + std::string str = "Test string!"; + + SHA1Hash sha1; + sha1.UpdateData(str); + uint32 magic = 0xFEEDFACE; // unsure + sha1.UpdateData((uint8*)&magic, 4); + sha1.Finalize(); + + uint8 sha1Hash[20]; + buff.read(sha1Hash, 20); + + if (memcmp(sha1Hash, sha1.GetDigest(), 20)) + { + sLog->outDebug(LOG_FILTER_WARDEN, "Handle data failed: SHA1 hash is wrong!"); + found = true; + } + + MD5_CTX ctx; + MD5_Init(&ctx); + MD5_Update(&ctx, str.c_str(), str.size()); + uint8 ourMD5Hash[16]; + MD5_Final(ourMD5Hash, &ctx); + + uint8 theirsMD5Hash[16]; + buff.read(theirsMD5Hash, 16); + + if (memcmp(ourMD5Hash, theirsMD5Hash, 16)) + { + sLog->outDebug(LOG_FILTER_WARDEN, "Handle data failed: MD5 hash is wrong!"); + found = true; + } + + _session->KickPlayer(); +} diff --git a/src/server/game/Warden/WardenMac.h b/src/server/game/Warden/WardenMac.h new file mode 100644 index 000000000..b2ecc7236 --- /dev/null +++ b/src/server/game/Warden/WardenMac.h @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDEN_MAC_H +#define _WARDEN_MAC_H + +#include "Cryptography/ARC4.h" +#include +#include "Cryptography/BigNumber.h" +#include "ByteBuffer.h" +#include "Warden.h" + +class WorldSession; +class Warden; + +class WardenMac : public Warden +{ + public: + WardenMac(); + ~WardenMac(); + + void Init(WorldSession* session, BigNumber* k); + ClientWardenModule* GetModuleForClient(); + void InitializeModule(); + void RequestHash(); + void HandleHashResult(ByteBuffer& buff); + void RequestData(); + void HandleData(ByteBuffer& buff); +}; + +#endif diff --git a/src/server/game/Warden/WardenWin.cpp b/src/server/game/Warden/WardenWin.cpp new file mode 100644 index 000000000..a77c77a32 --- /dev/null +++ b/src/server/game/Warden/WardenWin.cpp @@ -0,0 +1,523 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "Cryptography/HMACSHA1.h" +#include "Cryptography/WardenKeyGeneration.h" +#include "Common.h" +#include "WorldPacket.h" +#include "WorldSession.h" +#include "Log.h" +#include "Opcodes.h" +#include "ByteBuffer.h" +#include +#include "Database/DatabaseEnv.h" +#include "World.h" +#include "Player.h" +#include "Util.h" +#include "WardenWin.h" +#include "WardenModuleWin.h" +#include "WardenCheckMgr.h" +#include "AccountMgr.h" + +WardenWin::WardenWin() : Warden() +{ +} + +WardenWin::~WardenWin() +{ +} + +void WardenWin::Init(WorldSession* session, BigNumber *k) +{ + _session = session; + // Generate Warden Key + SHA1Randx WK(k->AsByteArray(), k->GetNumBytes()); + WK.generate(_inputKey, 16); + WK.generate(_outputKey, 16); + /* + Seed: 4D808D2C77D905C41A6380EC08586AFE (0x05 packet) + Hash: 568C054C781A972A6037A2290C22B52571A06F4E (0x04 packet) + Module MD5: 79C0768D657977D697E10BAD956CCED1 + New Client Key: 7F 96 EE FD A5 B6 3D 20 A4 DF 8E 00 CB F4 83 04 + New Cerver Key: C2 B7 AD ED FC CC A9 C2 BF B3 F8 56 02 BA 80 9B + */ + uint8 mod_seed[16] = { 0x4D, 0x80, 0x8D, 0x2C, 0x77, 0xD9, 0x05, 0xC4, 0x1A, 0x63, 0x80, 0xEC, 0x08, 0x58, 0x6A, 0xFE }; + + memcpy(_seed, mod_seed, 16); + + _inputCrypto.Init(_inputKey); + _outputCrypto.Init(_outputKey); + sLog->outDebug(LOG_FILTER_WARDEN, "Server side warden for client %u initializing...", session->GetAccountId()); + sLog->outDebug(LOG_FILTER_WARDEN, "C->S Key: %s", ByteArrayToHexStr(_inputKey, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "S->C Key: %s", ByteArrayToHexStr(_outputKey, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, " Seed: %s", ByteArrayToHexStr(_seed, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "Loading Module..."); + + _module = GetModuleForClient(); + + sLog->outDebug(LOG_FILTER_WARDEN, "Module Key: %s", ByteArrayToHexStr(_module->Key, 16).c_str()); + sLog->outDebug(LOG_FILTER_WARDEN, "Module ID: %s", ByteArrayToHexStr(_module->Id, 16).c_str()); + RequestModule(); +} + +ClientWardenModule* WardenWin::GetModuleForClient() +{ + ClientWardenModule *mod = new ClientWardenModule; + + uint32 length = sizeof(Module_79C0768D657977D697E10BAD956CCED1_Data); + + // data assign + mod->CompressedSize = length; + mod->CompressedData = new uint8[length]; + memcpy(mod->CompressedData, Module_79C0768D657977D697E10BAD956CCED1_Data, length); + memcpy(mod->Key, Module_79C0768D657977D697E10BAD956CCED1_Key, 16); + + // md5 hash + MD5_CTX ctx; + MD5_Init(&ctx); + MD5_Update(&ctx, mod->CompressedData, length); + MD5_Final((uint8*)&mod->Id, &ctx); + + return mod; +} + +void WardenWin::InitializeModule() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Initialize module"); + + // Create packet structure + WardenInitModuleRequest Request; + Request.Command1 = WARDEN_SMSG_MODULE_INITIALIZE; + Request.Size1 = 20; + Request.CheckSumm1 = BuildChecksum(&Request.Unk1, 20); + Request.Unk1 = 1; + Request.Unk2 = 0; + Request.Type = 1; + Request.String_library1 = 0; + Request.Function1[0] = 0x00024F80; // 0x00400000 + 0x00024F80 SFileOpenFile + Request.Function1[1] = 0x000218C0; // 0x00400000 + 0x000218C0 SFileGetFileSize + Request.Function1[2] = 0x00022530; // 0x00400000 + 0x00022530 SFileReadFile + Request.Function1[3] = 0x00022910; // 0x00400000 + 0x00022910 SFileCloseFile + + Request.Command2 = WARDEN_SMSG_MODULE_INITIALIZE; + Request.Size2 = 8; + Request.CheckSumm2 = BuildChecksum(&Request.Unk2, 8); + Request.Unk3 = 4; + Request.Unk4 = 0; + Request.String_library2 = 0; + Request.Function2 = 0x00419D40; // 0x00400000 + 0x00419D40 FrameScript::GetText + Request.Function2_set = 1; + + Request.Command3 = WARDEN_SMSG_MODULE_INITIALIZE; + Request.Size3 = 8; + Request.CheckSumm3 = BuildChecksum(&Request.Unk5, 8); + Request.Unk5 = 1; + Request.Unk6 = 1; + Request.String_library3 = 0; + Request.Function3 = 0x0046AE20; // 0x00400000 + 0x0046AE20 PerformanceCounter + Request.Function3_set = 1; + + // Encrypt with warden RC4 key. + EncryptData((uint8*)&Request, sizeof(WardenInitModuleRequest)); + + WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenInitModuleRequest)); + pkt.append((uint8*)&Request, sizeof(WardenInitModuleRequest)); + _session->SendPacket(&pkt); +} + +void WardenWin::RequestHash() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash"); + + // Create packet structure + WardenHashRequest Request; + Request.Command = WARDEN_SMSG_HASH_REQUEST; + memcpy(Request.Seed, _seed, 16); + + // Encrypt with warden RC4 key. + EncryptData((uint8*)&Request, sizeof(WardenHashRequest)); + + WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenHashRequest)); + pkt.append((uint8*)&Request, sizeof(WardenHashRequest)); + _session->SendPacket(&pkt); +} + +void WardenWin::HandleHashResult(ByteBuffer &buff) +{ + buff.rpos(buff.wpos()); + + const uint8 validHash[20] = { 0x56, 0x8C, 0x05, 0x4C, 0x78, 0x1A, 0x97, 0x2A, 0x60, 0x37, 0xA2, 0x29, 0x0C, 0x22, 0xB5, 0x25, 0x71, 0xA0, 0x6F, 0x4E }; + + // Verify key + if (memcmp(buff.contents() + 1, validHash, sizeof(validHash)) != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash reply: failed"); + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u) failed hash reply. Action: %s", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), Penalty().c_str()); + return; + } + + sLog->outDebug(LOG_FILTER_WARDEN, "Request hash reply: succeed"); + + // Client 7F96EEFDA5B63D20A4DF8E00CBF48304 + const uint8 client_key[16] = { 0x7F, 0x96, 0xEE, 0xFD, 0xA5, 0xB6, 0x3D, 0x20, 0xA4, 0xDF, 0x8E, 0x00, 0xCB, 0xF4, 0x83, 0x04 }; + + // Server C2B7ADEDFCCCA9C2BFB3F85602BA809B + const uint8 server_key[16] = { 0xC2, 0xB7, 0xAD, 0xED, 0xFC, 0xCC, 0xA9, 0xC2, 0xBF, 0xB3, 0xF8, 0x56, 0x02, 0xBA, 0x80, 0x9B }; + + // Change keys here + memcpy(_inputKey, client_key, 16); + memcpy(_outputKey, server_key, 16); + + _inputCrypto.Init(_inputKey); + _outputCrypto.Init(_outputKey); + + _initialized = true; + + _previousTimestamp = getMSTime(); +} + +void WardenWin::RequestData() +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Request data"); + + // If all checks were done, fill the todo list again + if (_memChecksTodo.empty()) + _memChecksTodo.assign(sWardenCheckMgr->MemChecksIdPool.begin(), sWardenCheckMgr->MemChecksIdPool.end()); + + if (_otherChecksTodo.empty()) + _otherChecksTodo.assign(sWardenCheckMgr->OtherChecksIdPool.begin(), sWardenCheckMgr->OtherChecksIdPool.end()); + + _serverTicks = getMSTime(); + + uint16 id; + uint8 type; + WardenCheck* wd; + _currentChecks.clear(); + + // Build check request + for (uint32 i = 0; i < sWorld->getIntConfig(CONFIG_WARDEN_NUM_MEM_CHECKS); ++i) + { + // If todo list is done break loop (will be filled on next Update() run) + if (_memChecksTodo.empty()) + break; + + // Get check id from the end and remove it from todo + id = _memChecksTodo.back(); + _memChecksTodo.pop_back(); + + // Add the id to the list sent in this cycle + _currentChecks.push_back(id); + } + + ByteBuffer buff; + buff << uint8(WARDEN_SMSG_CHEAT_CHECKS_REQUEST); + + for (uint32 i = 0; i < sWorld->getIntConfig(CONFIG_WARDEN_NUM_OTHER_CHECKS); ++i) + { + // If todo list is done break loop (will be filled on next Update() run) + if (_otherChecksTodo.empty()) + break; + + // Get check id from the end and remove it from todo + id = _otherChecksTodo.back(); + _otherChecksTodo.pop_back(); + + // Add the id to the list sent in this cycle + _currentChecks.push_back(id); + + wd = sWardenCheckMgr->GetWardenDataById(id); + + switch (wd->Type) + { + case MPQ_CHECK: + case LUA_STR_CHECK: + case DRIVER_CHECK: + buff << uint8(wd->Str.size()); + buff.append(wd->Str.c_str(), wd->Str.size()); + break; + default: + break; + } + } + + uint8 xorByte = _inputKey[0]; + + // Add TIMING_CHECK + buff << uint8(0x00); + buff << uint8(TIMING_CHECK ^ xorByte); + + uint8 index = 1; + + for (std::list::iterator itr = _currentChecks.begin(); itr != _currentChecks.end(); ++itr) + { + wd = sWardenCheckMgr->GetWardenDataById(*itr); + + type = wd->Type; + buff << uint8(type ^ xorByte); + switch (type) + { + case MEM_CHECK: + { + buff << uint8(0x00); + buff << uint32(wd->Address); + buff << uint8(wd->Length); + break; + } + case PAGE_CHECK_A: + case PAGE_CHECK_B: + { + buff.append(wd->Data.AsByteArray(0, false), wd->Data.GetNumBytes()); + buff << uint32(wd->Address); + buff << uint8(wd->Length); + break; + } + case MPQ_CHECK: + case LUA_STR_CHECK: + { + buff << uint8(index++); + break; + } + case DRIVER_CHECK: + { + buff.append(wd->Data.AsByteArray(0, false), wd->Data.GetNumBytes()); + buff << uint8(index++); + break; + } + case MODULE_CHECK: + { + uint32 seed = static_cast(rand32()); + buff << uint32(seed); + HmacHash hmac(4, (uint8*)&seed); + hmac.UpdateData(wd->Str); + hmac.Finalize(); + buff.append(hmac.GetDigest(), hmac.GetLength()); + break; + } + /*case PROC_CHECK: + { + buff.append(wd->i.AsByteArray(0, false), wd->i.GetNumBytes()); + buff << uint8(index++); + buff << uint8(index++); + buff << uint32(wd->Address); + buff << uint8(wd->Length); + break; + }*/ + default: + break; // Should never happen + } + } + buff << uint8(xorByte); + buff.hexlike(); + + // Encrypt with warden RC4 key + EncryptData(const_cast(buff.contents()), buff.size()); + + WorldPacket pkt(SMSG_WARDEN_DATA, buff.size()); + pkt.append(buff); + _session->SendPacket(&pkt); + + _dataSent = true; + + std::stringstream stream; + stream << "Sent check id's: "; + for (std::list::iterator itr = _currentChecks.begin(); itr != _currentChecks.end(); ++itr) + stream << *itr << " "; + + sLog->outWarden("%s", stream.str().c_str()); +} + +void WardenWin::HandleData(ByteBuffer &buff) +{ + sLog->outDebug(LOG_FILTER_WARDEN, "Handle data"); + + _dataSent = false; + _clientResponseTimer = 0; + + uint16 Length; + buff >> Length; + uint32 Checksum; + buff >> Checksum; + + if (!IsValidCheckSum(Checksum, buff.contents() + buff.rpos(), Length)) + { + buff.rpos(buff.wpos()); + sLog->outDebug(LOG_FILTER_WARDEN, "CHECKSUM FAIL"); + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u) failed checksum. Action: %s", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), Penalty().c_str()); + return; + } + + // TIMING_CHECK + { + uint8 result; + buff >> result; + // TODO: test it. + if (result == 0x00) + { + sLog->outDebug(LOG_FILTER_WARDEN, "TIMING CHECK FAIL result 0x00"); + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u) failed timing check. Action: %s", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), Penalty().c_str()); + return; + } + + uint32 newClientTicks; + buff >> newClientTicks; + + uint32 ticksNow = getMSTime(); + uint32 ourTicks = newClientTicks + (ticksNow - _serverTicks); + + sLog->outDebug(LOG_FILTER_WARDEN, "ServerTicks %u", ticksNow); // Now + sLog->outDebug(LOG_FILTER_WARDEN, "RequestTicks %u", _serverTicks); // At request + sLog->outDebug(LOG_FILTER_WARDEN, "Ticks %u", newClientTicks); // At response + sLog->outDebug(LOG_FILTER_WARDEN, "Ticks diff %u", ourTicks - newClientTicks); + } + + WardenCheckResult *rs; + WardenCheck *rd; + uint8 type; + uint16 checkFailed = 0; + + for (std::list::iterator itr = _currentChecks.begin(); itr != _currentChecks.end(); ++itr) + { + rd = sWardenCheckMgr->GetWardenDataById(*itr); + rs = sWardenCheckMgr->GetWardenResultById(*itr); + + type = rd->Type; + switch (type) + { + case MEM_CHECK: + { + uint8 Mem_Result; + buff >> Mem_Result; + + if (Mem_Result != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MEM_CHECK not 0x00, CheckId %u account Id %u", *itr, _session->GetAccountId()); + checkFailed = *itr; + continue; + } + + if (memcmp(buff.contents() + buff.rpos(), rs->Result.AsByteArray(0, false), rd->Length) != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MEM_CHECK fail CheckId %u account Id %u", *itr, _session->GetAccountId()); + checkFailed = *itr; + buff.rpos(buff.rpos() + rd->Length); + continue; + } + + buff.rpos(buff.rpos() + rd->Length); + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MEM_CHECK passed CheckId %u account Id %u", *itr, _session->GetAccountId()); + break; + } + case PAGE_CHECK_A: + case PAGE_CHECK_B: + case DRIVER_CHECK: + case MODULE_CHECK: + { + const uint8 byte = 0xE9; + if (memcmp(buff.contents() + buff.rpos(), &byte, sizeof(uint8)) != 0) + { + if (type == PAGE_CHECK_A || type == PAGE_CHECK_B) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT PAGE_CHECK fail, CheckId %u account Id %u", *itr, _session->GetAccountId()); + if (type == MODULE_CHECK) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MODULE_CHECK fail, CheckId %u account Id %u", *itr, _session->GetAccountId()); + if (type == DRIVER_CHECK) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT DRIVER_CHECK fail, CheckId %u account Id %u", *itr, _session->GetAccountId()); + checkFailed = *itr; + buff.rpos(buff.rpos() + 1); + continue; + } + + buff.rpos(buff.rpos() + 1); + if (type == PAGE_CHECK_A || type == PAGE_CHECK_B) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT PAGE_CHECK passed CheckId %u account Id %u", *itr, _session->GetAccountId()); + else if (type == MODULE_CHECK) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MODULE_CHECK passed CheckId %u account Id %u", *itr, _session->GetAccountId()); + else if (type == DRIVER_CHECK) + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT DRIVER_CHECK passed CheckId %u account Id %u", *itr, _session->GetAccountId()); + break; + } + case LUA_STR_CHECK: + { + uint8 Lua_Result; + buff >> Lua_Result; + + if (Lua_Result != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT LUA_STR_CHECK fail, CheckId %u account Id %u", *itr, _session->GetAccountId()); + checkFailed = *itr; + continue; + } + + uint8 luaStrLen; + buff >> luaStrLen; + + if (luaStrLen != 0) + { + char *str = new char[luaStrLen + 1]; + memset(str, 0, luaStrLen + 1); + memcpy(str, buff.contents() + buff.rpos(), luaStrLen); + sLog->outDebug(LOG_FILTER_WARDEN, "Lua string: %s", str); + delete[] str; + } + buff.rpos(buff.rpos() + luaStrLen); // Skip string + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT LUA_STR_CHECK passed, CheckId %u account Id %u", *itr, _session->GetAccountId()); + break; + } + case MPQ_CHECK: + { + uint8 Mpq_Result; + buff >> Mpq_Result; + + if (Mpq_Result != 0) + { + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MPQ_CHECK not 0x00 account id %u", _session->GetAccountId()); + checkFailed = *itr; + continue; + } + + if (memcmp(buff.contents() + buff.rpos(), rs->Result.AsByteArray(0, false), 20) != 0) // SHA1 + { + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MPQ_CHECK fail, CheckId %u account Id %u", *itr, _session->GetAccountId()); + checkFailed = *itr; + buff.rpos(buff.rpos() + 20); // 20 bytes SHA1 + continue; + } + + buff.rpos(buff.rpos() + 20); // 20 bytes SHA1 + sLog->outDebug(LOG_FILTER_WARDEN, "RESULT MPQ_CHECK passed, CheckId %u account Id %u", *itr, _session->GetAccountId()); + break; + } + default: // Should never happen + break; + } + } + + if (checkFailed > 0) + { + WardenCheck* check = sWardenCheckMgr->GetWardenDataById(checkFailed); + + sLog->outWarden("WARDEN: Player %s (guid: %u, account: %u) failed Warden check %u. Action: %s", + _session->GetPlayerName(), _session->GetGuidLow(), _session->GetAccountId(), checkFailed, Penalty(check).c_str()); + } + + // Set hold off timer, minimum timer should at least be 1 second + uint32 holdOff = sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF); + _checkTimer = (holdOff < 1 ? 1 : holdOff) * IN_MILLISECONDS; +} diff --git a/src/server/game/Warden/WardenWin.h b/src/server/game/Warden/WardenWin.h new file mode 100644 index 000000000..4d859f2b2 --- /dev/null +++ b/src/server/game/Warden/WardenWin.h @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#ifndef _WARDEN_WIN_H +#define _WARDEN_WIN_H + +#include +#include "Cryptography/ARC4.h" +#include "Cryptography/BigNumber.h" +#include "ByteBuffer.h" +#include "Warden.h" + +#if defined(__GNUC__) +#pragma pack(1) +#else +#pragma pack(push,1) +#endif + +struct WardenInitModuleRequest +{ + uint8 Command1; + uint16 Size1; + uint32 CheckSumm1; + uint8 Unk1; + uint8 Unk2; + uint8 Type; + uint8 String_library1; + uint32 Function1[4]; + + uint8 Command2; + uint16 Size2; + uint32 CheckSumm2; + uint8 Unk3; + uint8 Unk4; + uint8 String_library2; + uint32 Function2; + uint8 Function2_set; + + uint8 Command3; + uint16 Size3; + uint32 CheckSumm3; + uint8 Unk5; + uint8 Unk6; + uint8 String_library3; + uint32 Function3; + uint8 Function3_set; +}; + +#if defined(__GNUC__) +#pragma pack() +#else +#pragma pack(pop) +#endif + +class WorldSession; +class Warden; + +class WardenWin : public Warden +{ + public: + WardenWin(); + ~WardenWin(); + + void Init(WorldSession* session, BigNumber* K); + ClientWardenModule* GetModuleForClient(); + void InitializeModule(); + void RequestHash(); + void HandleHashResult(ByteBuffer &buff); + void RequestData(); + void HandleData(ByteBuffer &buff); + + private: + uint32 _serverTicks; + std::list _otherChecksTodo; + std::list _memChecksTodo; + std::list _currentChecks; +}; + +#endif diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp index 8b448516e..69c011014 100755 --- a/src/server/game/World/World.cpp +++ b/src/server/game/World/World.cpp @@ -75,6 +75,8 @@ #include "CreatureTextMgr.h" #include "SmartAI.h" #include "Channel.h" +#include "WardenCheckMgr.h" +#include "Warden.h" volatile bool World::m_stopEvent = false; uint8 World::m_ExitCode = SHUTDOWN_EXIT_CODE; @@ -1171,6 +1173,15 @@ void World::LoadConfigSettings(bool reload) m_bool_configs[CONFIG_CHATLOG_ADDON] = ConfigMgr::GetBoolDefault("ChatLogs.Addon", false); m_bool_configs[CONFIG_CHATLOG_BGROUND] = ConfigMgr::GetBoolDefault("ChatLogs.Battleground", false); + // Warden + m_bool_configs[CONFIG_WARDEN_ENABLED] = ConfigMgr::GetBoolDefault("Warden.Enabled", false); + m_int_configs[CONFIG_WARDEN_NUM_MEM_CHECKS] = ConfigMgr::GetIntDefault("Warden.NumMemChecks", 3); + m_int_configs[CONFIG_WARDEN_NUM_OTHER_CHECKS] = ConfigMgr::GetIntDefault("Warden.NumOtherChecks", 7); + m_int_configs[CONFIG_WARDEN_CLIENT_BAN_DURATION] = ConfigMgr::GetIntDefault("Warden.BanDuration", 86400); + m_int_configs[CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF] = ConfigMgr::GetIntDefault("Warden.ClientCheckHoldOff", 30); + m_int_configs[CONFIG_WARDEN_CLIENT_FAIL_ACTION] = ConfigMgr::GetIntDefault("Warden.ClientCheckFailAction", 0); + m_int_configs[CONFIG_WARDEN_CLIENT_RESPONSE_DELAY] = ConfigMgr::GetIntDefault("Warden.ClientResponseDelay", 600); + // Dungeon finder m_bool_configs[CONFIG_DUNGEON_FINDER_ENABLE] = ConfigMgr::GetBoolDefault("DungeonFinder.Enable", false); @@ -1286,7 +1297,7 @@ void World::SetInitialWorldSettings() sLog->outString("Loading GameObject models..."); LoadGameObjectModelList(); - + sLog->outString("Loading Script Names..."); sObjectMgr->LoadScriptNames(); @@ -1589,6 +1600,9 @@ void World::SetInitialWorldSettings() sLog->outString("Loading Creature Formations..."); FormationMgr::LoadCreatureFormations(); + sLog->outString("Loading World States..."); // must be loaded before battleground, outdoor PvP and conditions + LoadWorldStates(); + sLog->outString("Loading Conditions..."); sConditionMgr->LoadConditions(); @@ -1716,9 +1730,6 @@ void World::SetInitialWorldSettings() sTicketMgr->Initialize(); - sLog->outString("Loading World States..."); // must be loaded before battleground and outdoor PvP - LoadWorldStates(); - ///- Initialize Battlegrounds sLog->outString("Starting Battleground System"); sBattlegroundMgr->CreateInitialBattlegrounds(); @@ -1738,6 +1749,10 @@ void World::SetInitialWorldSettings() sLog->outString("Loading Transport NPCs..."); sMapMgr->LoadTransportNPCs(); + ///- Initialize Warden + sLog->outString("Loading Warden Checks..." ); + sWardenCheckMgr->LoadWardenChecks(); + sLog->outString("Deleting expired bans..."); LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate <= UNIX_TIMESTAMP() AND unbandate<>bandate"); diff --git a/src/server/game/World/World.h b/src/server/game/World/World.h index 2f672ae21..c955544a7 100755 --- a/src/server/game/World/World.h +++ b/src/server/game/World/World.h @@ -162,6 +162,7 @@ enum WorldBoolConfigs CONFIG_PDUMP_NO_OVERWRITE, CONFIG_QUEST_IGNORE_AUTO_ACCEPT, CONFIG_QUEST_IGNORE_AUTO_COMPLETE, + CONFIG_WARDEN_ENABLED, CONFIG_WINTERGRASP_ENABLE, BOOL_CONFIG_VALUE_COUNT }; @@ -310,6 +311,12 @@ enum WorldIntConfigs CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION, CONFIG_PERSISTENT_CHARACTER_CLEAN_FLAGS, CONFIG_MAX_INSTANCES_PER_HOUR, + CONFIG_WARDEN_CLIENT_RESPONSE_DELAY, + CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF, + CONFIG_WARDEN_CLIENT_FAIL_ACTION, + CONFIG_WARDEN_CLIENT_BAN_DURATION, + CONFIG_WARDEN_NUM_MEM_CHECKS, + CONFIG_WARDEN_NUM_OTHER_CHECKS, CONFIG_WINTERGRASP_PLR_MAX, CONFIG_WINTERGRASP_PLR_MIN, CONFIG_WINTERGRASP_PLR_MIN_LVL, diff --git a/src/server/scripts/CMakeLists.txt b/src/server/scripts/CMakeLists.txt index 4f7f871df..4de2e477c 100644 --- a/src/server/scripts/CMakeLists.txt +++ b/src/server/scripts/CMakeLists.txt @@ -140,6 +140,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/src/server/game/Texts ${CMAKE_SOURCE_DIR}/src/server/game/Tickets ${CMAKE_SOURCE_DIR}/src/server/game/Tools + ${CMAKE_SOURCE_DIR}/src/server/game/Warden + ${CMAKE_SOURCE_DIR}/src/server/game/Warden/Modules ${CMAKE_SOURCE_DIR}/src/server/game/Weather ${CMAKE_SOURCE_DIR}/src/server/game/World ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders diff --git a/src/server/scripts/Commands/cs_debug.cpp b/src/server/scripts/Commands/cs_debug.cpp index 73e6b0ac8..8ca402310 100644 --- a/src/server/scripts/Commands/cs_debug.cpp +++ b/src/server/scripts/Commands/cs_debug.cpp @@ -1041,8 +1041,8 @@ public: handler->GetSession()->GetPlayer()->HandleEmoteCommand(animId); return true; } - - static bool HandleDebugLoSCommand(ChatHandler* handler, char const* args) + + static bool HandleDebugLoSCommand(ChatHandler* handler, char const* /*args*/) { if (Unit* unit = handler->getSelectedUnit()) handler->PSendSysMessage("Unit %s (GuidLow: %u) is %sin LoS", unit->GetName(), unit->GetGUIDLow(), handler->GetSession()->GetPlayer()->IsWithinLOSInMap(unit) ? "" : "not "); diff --git a/src/server/scripts/Commands/cs_go.cpp b/src/server/scripts/Commands/cs_go.cpp index 3de0d89ba..f7371884d 100644 --- a/src/server/scripts/Commands/cs_go.cpp +++ b/src/server/scripts/Commands/cs_go.cpp @@ -496,7 +496,7 @@ public: float z; float ort = port ? (float)atof(port) : player->GetOrientation(); uint32 mapId = id ? (uint32)atoi(id) : player->GetMapId(); - + if (goZ) { z = (float)atof(goZ); diff --git a/src/server/scripts/EasternKingdoms/AlteracValley/boss_vanndar.cpp b/src/server/scripts/EasternKingdoms/AlteracValley/boss_vanndar.cpp index 54fcb9d99..3960351d3 100644 --- a/src/server/scripts/EasternKingdoms/AlteracValley/boss_vanndar.cpp +++ b/src/server/scripts/EasternKingdoms/AlteracValley/boss_vanndar.cpp @@ -24,7 +24,7 @@ enum Yells YELL_RESPAWN1 = -1810010, // no creature_text YELL_RESPAWN2 = -1810011, // no creature_text YELL_RANDOM = 2, - YELL_SPELL = 3, + YELL_SPELL = 3, }; enum Spells diff --git a/src/server/scripts/EasternKingdoms/BlackrockDepths/blackrock_depths.cpp b/src/server/scripts/EasternKingdoms/BlackrockDepths/blackrock_depths.cpp index 17cf77560..7ef11e525 100644 --- a/src/server/scripts/EasternKingdoms/BlackrockDepths/blackrock_depths.cpp +++ b/src/server/scripts/EasternKingdoms/BlackrockDepths/blackrock_depths.cpp @@ -1301,7 +1301,7 @@ void AddSC_blackrock_depths() new npc_kharan_mighthammer(); new npc_lokhtos_darkbargainer(); new npc_rocknot(); - // Fix us + // Fix us /*new npc_dughal_stormwing(); new npc_tobias_seecher(); new npc_marshal_windsor(); diff --git a/src/server/scripts/EasternKingdoms/Uldaman/uldaman.cpp b/src/server/scripts/EasternKingdoms/Uldaman/uldaman.cpp index 7bcd25982..1c6cad727 100644 --- a/src/server/scripts/EasternKingdoms/Uldaman/uldaman.cpp +++ b/src/server/scripts/EasternKingdoms/Uldaman/uldaman.cpp @@ -143,125 +143,10 @@ class AreaTrigger_at_map_chamber : public AreaTriggerScript } }; -/*###### -## npc_lore_keeper_of_norgannon -######*/ - -#define GOSSIP_HELLO_KEEPER "Who are the Earthen?" -#define GOSSIP_SELECT_KEEPER1 "What is a \"subterranean being matrix\"?" -#define GOSSIP_SELECT_KEEPER2 "What are the anomalies you speak of?" -#define GOSSIP_SELECT_KEEPER3 "What is a resilient foundation of construction?" -#define GOSSIP_SELECT_KEEPER4 "So... the Earthen were made out of stone?" -#define GOSSIP_SELECT_KEEPER5 "Anything else I should know about the Earthen?" -#define GOSSIP_SELECT_KEEPER6 "I think I understand the Creators' design intent for the Earthen now. What are the Earthen's anomalies that you spoke of earlier?" -#define GOSSIP_SELECT_KEEPER7 "What high-stress environments would cause the Earthen to destabilize?" -#define GOSSIP_SELECT_KEEPER8 "What happens when the Earthen destabilize?" -#define GOSSIP_SELECT_KEEPER9 "Troggs?! Are the troggs you mention the same as the ones in the world today?" -#define GOSSIP_SELECT_KEEPER10 "You mentioned two results when the Earthen destabilize. What is the second?" -#define GOSSIP_SELECT_KEEPER11 "Dwarves!!! Now you're telling me that dwarves originally came from the Earthen?!" -#define GOSSIP_SELECT_KEEPER12 "These dwarves are the same ones today, yes? Do the dwarves maintain any other links to the Earthen?" -#define GOSSIP_SELECT_KEEPER13 "Who are the Creators?" -#define GOSSIP_SELECT_KEEPER14 "This is a lot to think about." -#define GOSSIP_SELECT_KEEPER15 "I will access the discs now." - -class npc_lore_keeper_of_norgannon : public CreatureScript -{ - public: - - npc_lore_keeper_of_norgannon() - : CreatureScript("npc_lore_keeper_of_norgannon") - { - } - - bool OnGossipHello(Player* player, Creature* creature) - { - if (player->GetQuestStatus(2278) == QUEST_STATUS_INCOMPLETE) - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_HELLO_KEEPER, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1); - - player->SEND_GOSSIP_MENU(1079, creature->GetGUID()); - - return true; - } - - bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction) - { - player->PlayerTalkClass->ClearMenus(); - switch (uiAction) - { - case GOSSIP_ACTION_INFO_DEF+1: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2); - player->SEND_GOSSIP_MENU(1080, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+2: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+3); - player->SEND_GOSSIP_MENU(1081, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+3: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+4); - player->SEND_GOSSIP_MENU(1082, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+4: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+5); - player->SEND_GOSSIP_MENU(1083, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+5: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+6); - player->SEND_GOSSIP_MENU(1084, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+6: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER6, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+7); - player->SEND_GOSSIP_MENU(1085, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+7: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER7, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+8); - player->SEND_GOSSIP_MENU(1086, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+8: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER8, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+9); - player->SEND_GOSSIP_MENU(1087, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+9: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER9, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+10); - player->SEND_GOSSIP_MENU(1088, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+10: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER10, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+11); - player->SEND_GOSSIP_MENU(1089, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+11: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER11, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+12); - player->SEND_GOSSIP_MENU(1090, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+12: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER12, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+13); - player->SEND_GOSSIP_MENU(1091, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+13: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER13, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+14); - player->SEND_GOSSIP_MENU(1092, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+14: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER14, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+15); - player->SEND_GOSSIP_MENU(1093, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+15: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_SELECT_KEEPER15, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+16); - player->SEND_GOSSIP_MENU(1094, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+16: - player->CLOSE_GOSSIP_MENU(); - player->AreaExploredOrEventHappens(2278); - break; - } - return true; - } -}; - void AddSC_uldaman() { new mob_jadespine_basilisk(); new go_keystone_chamber(); new AreaTrigger_at_map_chamber(); - new npc_lore_keeper_of_norgannon(); } diff --git a/src/server/scripts/EasternKingdoms/arathi_highlands.cpp b/src/server/scripts/EasternKingdoms/arathi_highlands.cpp index e2a971788..82b09b9dc 100644 --- a/src/server/scripts/EasternKingdoms/arathi_highlands.cpp +++ b/src/server/scripts/EasternKingdoms/arathi_highlands.cpp @@ -73,7 +73,7 @@ class npc_professor_phizzlethorpe : public CreatureScript switch (uiPointId) { - case 4:Talk(SAY_PROGRESS_2, player->GetGUID());break; + case 4:Talk(SAY_PROGRESS_2, player->GetGUID());break; case 5:Talk(SAY_PROGRESS_3, player->GetGUID());break; case 8:Talk(EMOTE_PROGRESS_4);break; case 9: diff --git a/src/server/scripts/EasternKingdoms/blasted_lands.cpp b/src/server/scripts/EasternKingdoms/blasted_lands.cpp index 1e34051db..2ad03f8b5 100644 --- a/src/server/scripts/EasternKingdoms/blasted_lands.cpp +++ b/src/server/scripts/EasternKingdoms/blasted_lands.cpp @@ -19,13 +19,12 @@ /* ScriptData SDName: Blasted_Lands SD%Complete: 90 -SDComment: Quest support: 2784, 2801, 3628. Missing some texts for Fallen Hero. Teleporter to Rise of the Defiler missing group support. +SDComment: Quest support: 3628. Teleporter to Rise of the Defiler missing group support. SDCategory: Blasted Lands EndScriptData */ /* ContentData npc_deathly_usher -npc_fallen_hero_of_horde EndContentData */ #include "ScriptPCH.h" @@ -69,115 +68,7 @@ public: }; -/*###### -## npc_fallen_hero_of_horde -######*/ - -enum HeroesOfOld -{ - QUEST_HEROES_OF_OLD = 2702, - NPC_THUND_SPLITHOOF = 7750, -}; - -#define GOSSIP_H_F1 "Why are you here?" -#define GOSSIP_H_F2 "Continue story..." - -#define GOSSIP_ITEM_FALLEN "Continue..." - -#define GOSSIP_ITEM_FALLEN1 "What could be worse than death?" -#define GOSSIP_ITEM_FALLEN2 "Subordinates?" -#define GOSSIP_ITEM_FALLEN3 "What are the stones of binding?" -#define GOSSIP_ITEM_FALLEN4 "You can count on me, Hero" -#define GOSSIP_ITEM_FALLEN5 "I shall" - -class npc_fallen_hero_of_horde : public CreatureScript -{ -public: - npc_fallen_hero_of_horde() : CreatureScript("npc_fallen_hero_of_horde") { } - - bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction) - { - player->PlayerTalkClass->ClearMenus(); - switch (uiAction) - { - case GOSSIP_ACTION_INFO_DEF+1: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 11); - player->SEND_GOSSIP_MENU(1392, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+11: - player->SEND_GOSSIP_MENU(1411, creature->GetGUID()); - if (player->GetQuestStatus(2784) == QUEST_STATUS_INCOMPLETE) - player->AreaExploredOrEventHappens(2784); - if (player->GetTeam() == ALLIANCE) - { - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 2); - player->SEND_GOSSIP_MENU(1411, creature->GetGUID()); - } - break; - - case GOSSIP_ACTION_INFO_DEF+2: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 21); - player->SEND_GOSSIP_MENU(1451, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+21: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 22); - player->SEND_GOSSIP_MENU(1452, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+22: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 23); - player->SEND_GOSSIP_MENU(1453, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+23: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN3, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 24); - player->SEND_GOSSIP_MENU(1454, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+24: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN4, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 25); - player->SEND_GOSSIP_MENU(1455, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+25: - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_ITEM_FALLEN5, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF + 26); - player->SEND_GOSSIP_MENU(1456, creature->GetGUID()); - break; - case GOSSIP_ACTION_INFO_DEF+26: - player->CLOSE_GOSSIP_MENU(); - player->AreaExploredOrEventHappens(2801); - break; - } - return true; - } - - bool OnGossipHello(Player* player, Creature* creature) - { - if (creature->isQuestGiver()) - player->PrepareQuestMenu(creature->GetGUID()); - - if (player->GetQuestStatus(2784) == QUEST_STATUS_INCOMPLETE) - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_H_F1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1); - - if (player->GetQuestStatus(2801) == QUEST_STATUS_INCOMPLETE && player->GetTeam() == HORDE) - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_H_F2, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+2); - - if (player->GetQuestStatus(2801) == QUEST_STATUS_INCOMPLETE && player->GetTeam() == ALLIANCE) - player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, GOSSIP_H_F1, GOSSIP_SENDER_MAIN, GOSSIP_ACTION_INFO_DEF+1); - - player->SEND_GOSSIP_MENU(player->GetGossipTextId(creature), creature->GetGUID()); - - return true; - } - - bool OnQuestAccept(Player* /*player*/, Creature* creature, Quest const* quest) - { - if (quest->GetQuestId() == QUEST_HEROES_OF_OLD) - creature->SummonCreature(NPC_THUND_SPLITHOOF, -10630.3f, -2987.05f, 28.96f, 4.54f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 9000000); - - return true; - } - -}; - void AddSC_blasted_lands() { new npc_deathly_usher(); - new npc_fallen_hero_of_horde(); } diff --git a/src/server/scripts/Examples/example_spell.cpp b/src/server/scripts/Examples/example_spell.cpp index b1a8f17d1..71dbd7f4f 100644 --- a/src/server/scripts/Examples/example_spell.cpp +++ b/src/server/scripts/Examples/example_spell.cpp @@ -93,14 +93,14 @@ class spell_ex_5581 : public SpellScriptLoader void HandleAfterCast() { sLog->outString("All immediate actions for the spell are finished now"); - // this is a safe for triggering additional effects for a spell without interfering + // this is a safe for triggering additional effects for a spell without interfering // with visuals or with other effects of the spell //GetCaster()->CastSpell(target, SPELL_TRIGGERED, true); } SpellCastResult CheckRequirement() { - // in this hook you can add additional requirements for spell caster (and throw a client error if reqs're not passed) + // in this hook you can add additional requirements for spell caster (and throw a client error if reqs're not passed) // in this case we're disallowing to select non-player as a target of the spell //if (!GetTargetUnit() || GetTargetUnit()->ToPlayer()) //return SPELL_FAILED_BAD_TARGETS; diff --git a/src/server/scripts/Kalimdor/BlackfathomDeeps/blackfathom_deeps.cpp b/src/server/scripts/Kalimdor/BlackfathomDeeps/blackfathom_deeps.cpp index 878116ad4..3bfaa448b 100644 --- a/src/server/scripts/Kalimdor/BlackfathomDeeps/blackfathom_deeps.cpp +++ b/src/server/scripts/Kalimdor/BlackfathomDeeps/blackfathom_deeps.cpp @@ -165,14 +165,14 @@ public: DoCast(target, SPELL_FROST_BOLT_VOLLEY); } frostBoltVolleyTimer = urand(5000, 8000); - } + } else frostBoltVolleyTimer -= diff; - + if (frostNovaTimer <= diff) { DoCastAOE(SPELL_FROST_NOVA, false); frostNovaTimer = urand(25000, 30000); - } + } else frostNovaTimer -= diff; break; } diff --git a/src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/hyjalAI.cpp b/src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/hyjalAI.cpp index 0caec3c70..107c9e8f2 100644 --- a/src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/hyjalAI.cpp +++ b/src/server/scripts/Kalimdor/CavernsOfTime/BattleForMountHyjal/hyjalAI.cpp @@ -947,7 +947,7 @@ void hyjalAI::HideNearPos(float x, float y) Trinity::AllFriendlyCreaturesInGrid creature_check(me); Trinity::CreatureListSearcher creature_searcher(me, creatures, creature_check); - TypeContainerVisitor , GridTypeMapContainer> creature_visitor(creature_searcher); + TypeContainerVisitor , GridTypeMapContainer> creature_visitor(creature_searcher); cell.Visit(pair, creature_visitor, *(me->GetMap()), *me, me->GetGridActivationRange()); if (!creatures.empty()) diff --git a/src/server/scripts/Kalimdor/CavernsOfTime/EscapeFromDurnholdeKeep/old_hillsbrad.cpp b/src/server/scripts/Kalimdor/CavernsOfTime/EscapeFromDurnholdeKeep/old_hillsbrad.cpp index b2c4911a2..aa57b3d94 100644 --- a/src/server/scripts/Kalimdor/CavernsOfTime/EscapeFromDurnholdeKeep/old_hillsbrad.cpp +++ b/src/server/scripts/Kalimdor/CavernsOfTime/EscapeFromDurnholdeKeep/old_hillsbrad.cpp @@ -139,9 +139,9 @@ public: #define SPEED_RUN (1.0f) #define SPEED_MOUNT (1.6f) -#define THRALL_WEAPON_MODEL 22106 +#define THRALL_WEAPON_ITEM 927 #define THRALL_WEAPON_INFO 218169346 -#define THRALL_SHIELD_MODEL 18662 +#define THRALL_SHIELD_ITEM 2129 #define THRALL_SHIELD_INFO 234948100 #define THRALL_MODEL_UNEQUIPPED 17292 #define THRALL_MODEL_EQUIPPED 18165 @@ -309,10 +309,10 @@ public: break; case 9: DoScriptText(SAY_TH_ARMORY, me); - me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, THRALL_WEAPON_MODEL); + me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, THRALL_WEAPON_ITEM); //me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO, THRALL_WEAPON_INFO); //me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+1, 781); - me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, THRALL_SHIELD_MODEL); + me->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID+1, THRALL_SHIELD_ITEM); //me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+2, THRALL_SHIELD_INFO); //me->SetUInt32Value(UNIT_VIRTUAL_ITEM_INFO+3, 1038); break; diff --git a/src/server/scripts/Kalimdor/Maraudon/boss_celebras_the_cursed.cpp b/src/server/scripts/Kalimdor/Maraudon/boss_celebras_the_cursed.cpp index 74e7a9192..38d9ce315 100644 --- a/src/server/scripts/Kalimdor/Maraudon/boss_celebras_the_cursed.cpp +++ b/src/server/scripts/Kalimdor/Maraudon/boss_celebras_the_cursed.cpp @@ -77,7 +77,7 @@ public: if (target) DoCast(target, SPELL_WRATH); Wrath_Timer = 8000; - } + } else Wrath_Timer -= diff; //EntanglingRoots @@ -85,7 +85,7 @@ public: { DoCast(me->getVictim(), SPELL_ENTANGLINGROOTS); EntanglingRoots_Timer = 20000; - } + } else EntanglingRoots_Timer -= diff; //CorruptForces @@ -94,7 +94,7 @@ public: me->InterruptNonMeleeSpells(false); DoCast(me, SPELL_CORRUPT_FORCES); CorruptForces_Timer = 20000; - } + } else CorruptForces_Timer -= diff; DoMeleeAttackIfReady(); diff --git a/src/server/scripts/Kalimdor/Maraudon/boss_landslide.cpp b/src/server/scripts/Kalimdor/Maraudon/boss_landslide.cpp index 418bf3a09..ea419793a 100644 --- a/src/server/scripts/Kalimdor/Maraudon/boss_landslide.cpp +++ b/src/server/scripts/Kalimdor/Maraudon/boss_landslide.cpp @@ -71,7 +71,7 @@ public: { DoCast(me->getVictim(), SPELL_KNOCKAWAY); KnockAway_Timer = 15000; - } + } else KnockAway_Timer -= diff; //Trample_Timer @@ -79,7 +79,7 @@ public: { DoCast(me, SPELL_TRAMPLE); Trample_Timer = 8000; - } + } else Trample_Timer -= diff; //Landslide @@ -90,7 +90,7 @@ public: me->InterruptNonMeleeSpells(false); DoCast(me, SPELL_LANDSLIDE); Landslide_Timer = 60000; - } + } else Landslide_Timer -= diff; } diff --git a/src/server/scripts/Kalimdor/Maraudon/boss_noxxion.cpp b/src/server/scripts/Kalimdor/Maraudon/boss_noxxion.cpp index 0e3ee5dc5..18ce7be0f 100644 --- a/src/server/scripts/Kalimdor/Maraudon/boss_noxxion.cpp +++ b/src/server/scripts/Kalimdor/Maraudon/boss_noxxion.cpp @@ -80,7 +80,7 @@ public: me->SetDisplayId(11172); Invisible = false; //me->m_canMove = true; - } + } else if (Invisible) { Invisible_Timer -= diff; @@ -97,7 +97,7 @@ public: { DoCast(me->getVictim(), SPELL_TOXICVOLLEY); ToxicVolley_Timer = 9000; - } + } else ToxicVolley_Timer -= diff; //Uppercut_Timer @@ -105,7 +105,7 @@ public: { DoCast(me->getVictim(), SPELL_UPPERCUT); Uppercut_Timer = 12000; - } + } else Uppercut_Timer -= diff; //Adds_Timer @@ -127,7 +127,7 @@ public: Invisible_Timer = 15000; Adds_Timer = 40000; - } + } else Adds_Timer -= diff; DoMeleeAttackIfReady(); diff --git a/src/server/scripts/Kalimdor/Maraudon/boss_princess_theradras.cpp b/src/server/scripts/Kalimdor/Maraudon/boss_princess_theradras.cpp index bade5655f..039d30071 100644 --- a/src/server/scripts/Kalimdor/Maraudon/boss_princess_theradras.cpp +++ b/src/server/scripts/Kalimdor/Maraudon/boss_princess_theradras.cpp @@ -77,7 +77,7 @@ public: { DoCast(me, SPELL_DUSTFIELD); Dustfield_Timer = 14000; - } + } else Dustfield_Timer -= diff; //Boulder_Timer @@ -88,7 +88,7 @@ public: if (target) DoCast(target, SPELL_BOULDER); Boulder_Timer = 10000; - } + } else Boulder_Timer -= diff; //RepulsiveGaze_Timer @@ -96,7 +96,7 @@ public: { DoCast(me->getVictim(), SPELL_REPULSIVEGAZE); RepulsiveGaze_Timer = 20000; - } + } else RepulsiveGaze_Timer -= diff; //Thrash_Timer @@ -104,7 +104,7 @@ public: { DoCast(me, SPELL_THRASH); Thrash_Timer = 18000; - } + } else Thrash_Timer -= diff; DoMeleeAttackIfReady(); diff --git a/src/server/scripts/Kalimdor/ZulFarrak/zulfarrak.cpp b/src/server/scripts/Kalimdor/ZulFarrak/zulfarrak.cpp index dd90eaa0e..61fe52640 100644 --- a/src/server/scripts/Kalimdor/ZulFarrak/zulfarrak.cpp +++ b/src/server/scripts/Kalimdor/ZulFarrak/zulfarrak.cpp @@ -44,8 +44,8 @@ enum blyAndCrewFactions enum blySays { - SAY_1 = -1209002, - SAY_2 = -1209003 + SAY_1 = 0, + SAY_2 = 1 }; enum blySpells @@ -133,11 +133,11 @@ public: //weegli doesn't fight - he goes & blows up the door if (Creature* pWeegli = instance->instance->GetCreature(instance->GetData64(ENTRY_WEEGLI))) pWeegli->AI()->DoAction(0); - DoScriptText(SAY_1, me); + Talk(SAY_1); Text_Timer = 5000; break; case 2: - DoScriptText(SAY_2, me); + Talk(SAY_2); Text_Timer = 5000; break; case 3: diff --git a/src/server/scripts/Kalimdor/desolace.cpp b/src/server/scripts/Kalimdor/desolace.cpp index 421a1d7b3..49a9be21a 100644 --- a/src/server/scripts/Kalimdor/desolace.cpp +++ b/src/server/scripts/Kalimdor/desolace.cpp @@ -175,7 +175,7 @@ public: ## Hand of Iruxos ######*/ -enum +enum { QUEST_HAND_IRUXOS = 5381, NPC_DEMON_SPIRIT = 11876, diff --git a/src/server/scripts/Kalimdor/silithus.cpp b/src/server/scripts/Kalimdor/silithus.cpp index e6322591b..fac56021c 100644 --- a/src/server/scripts/Kalimdor/silithus.cpp +++ b/src/server/scripts/Kalimdor/silithus.cpp @@ -1425,7 +1425,7 @@ class go_wind_stone : public GameObjectScript break; } - player->SEND_GOSSIP_MENU(player->GetGossipTextId(gossipId), go->GetGUID()); + player->SEND_GOSSIP_MENU(player->GetGossipTextId(gossipId, go), go->GetGUID()); return true; } diff --git a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_lord_jaraxxus.cpp b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_lord_jaraxxus.cpp index fc01ad2ef..6cd049967 100755 --- a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_lord_jaraxxus.cpp +++ b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_lord_jaraxxus.cpp @@ -68,7 +68,6 @@ enum BossSpells { SPELL_LEGION_FLAME = 66197, // player should run away from raid because he triggers Legion Flame SPELL_LEGION_FLAME_EFFECT = 66201, // used by trigger npc - SPELL_TOUCH_OF_JARAXXUS = 66209, // used only in 25H SPELL_NETHER_POWER = 66228, // +20% of spell damage per stack, stackable up to 5/10 times, must be dispelled/stealed SPELL_FEL_LIGHTING = 66528, // jumps to nearby targets SPELL_FEL_FIREBALL = 66532, // does heavy damage to the tank, interruptable @@ -120,7 +119,6 @@ public: uint32 m_uiIncinerateFleshTimer; uint32 m_uiNetherPowerTimer; uint32 m_uiLegionFlameTimer; - uint32 m_uiTouchOfJaraxxusTimer; uint32 m_uiSummonNetherPortalTimer; uint32 m_uiSummonInfernalEruptionTimer; @@ -134,7 +132,6 @@ public: m_uiIncinerateFleshTimer = urand(20*IN_MILLISECONDS, 25*IN_MILLISECONDS); m_uiNetherPowerTimer = 40*IN_MILLISECONDS; m_uiLegionFlameTimer = 30*IN_MILLISECONDS; - m_uiTouchOfJaraxxusTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS); m_uiSummonNetherPortalTimer = 1*MINUTE*IN_MILLISECONDS; m_uiSummonInfernalEruptionTimer = 2*MINUTE*IN_MILLISECONDS; Summons.DespawnAll(); @@ -240,13 +237,6 @@ public: m_uiLegionFlameTimer = 30*IN_MILLISECONDS; } else m_uiLegionFlameTimer -= uiDiff; - if (GetDifficulty() == RAID_DIFFICULTY_25MAN_HEROIC && m_uiTouchOfJaraxxusTimer <= uiDiff) - { - if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0)) - DoCast(target, SPELL_TOUCH_OF_JARAXXUS); - m_uiTouchOfJaraxxusTimer = urand(10*IN_MILLISECONDS, 15*IN_MILLISECONDS); - } else m_uiTouchOfJaraxxusTimer -= uiDiff; - DoMeleeAttackIfReady(); } }; diff --git a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_twin_valkyr.cpp b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_twin_valkyr.cpp index c1009963d..242b2f2f0 100755 --- a/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_twin_valkyr.cpp +++ b/src/server/scripts/Northrend/CrusadersColiseum/TrialOfTheCrusader/boss_twin_valkyr.cpp @@ -308,7 +308,7 @@ struct boss_twin_baseAI : public ScriptedAI void EnableDualWield(bool mode = true) { - SetEquipmentSlots(false, m_uiWeapon, mode ? m_uiWeapon : EQUIP_UNEQUIP, EQUIP_UNEQUIP); + SetEquipmentSlots(false, m_uiWeapon, mode ? m_uiWeapon : int32(EQUIP_UNEQUIP), EQUIP_UNEQUIP); me->SetCanDualWield(mode); me->UpdateDamagePhysical(mode ? OFF_ATTACK : BASE_ATTACK); } @@ -562,11 +562,13 @@ struct mob_unleashed_ballAI : public ScriptedAI { float x0 = ToCCommonLoc[1].GetPositionX(), y0 = ToCCommonLoc[1].GetPositionY(), r = 47.0f; float y = y0; - float x = float(urand(uint32(x0 - r), uint32(x0 + r))); + float x = frand(x0 - r, x0 + r); + float sq = pow(r, 2) - pow(x - x0, 2); + float rt = sqrtf(fabs(sq)); if (urand(0, 1)) - y = y0 + sqrt(pow(r, 2) - pow((x-x0), 2)); + y = y0 + rt; else - y = y0 - sqrt(pow(r, 2) - pow((x-x0), 2)); + y = y0 - rt; me->GetMotionMaster()->MovePoint(0, x, y, me->GetPositionZ()); } diff --git a/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp b/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp index 25cd292d3..a91951ca2 100644 --- a/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp +++ b/src/server/scripts/Northrend/FrozenHalls/PitOfSaron/pit_of_saron.cpp @@ -289,7 +289,7 @@ class spell_trash_mob_glacial_strike : public SpellScriptLoader { if (GetTarget()->IsFullHealth()) { - GetTarget()->RemoveAura(GetId(), AURA_REMOVE_BY_ENEMY_SPELL); + GetTarget()->RemoveAura(GetId(), 0, 0, AURA_REMOVE_BY_ENEMY_SPELL); PreventDefaultAction(); } } diff --git a/src/server/scripts/Northrend/IcecrownCitadel/boss_the_lich_king.cpp b/src/server/scripts/Northrend/IcecrownCitadel/boss_the_lich_king.cpp index b2ee05722..fbed870eb 100644 --- a/src/server/scripts/Northrend/IcecrownCitadel/boss_the_lich_king.cpp +++ b/src/server/scripts/Northrend/IcecrownCitadel/boss_the_lich_king.cpp @@ -501,13 +501,6 @@ class boss_the_lich_king : public CreatureScript DoCastAOE(SPELL_PLAY_MOVIE, false); me->RemoveUnitMovementFlag(MOVEMENTFLAG_LEVITATING); me->RemoveByteFlag(UNIT_FIELD_BYTES_1, 3, 0x03); - float x, y, z; - me->GetPosition(x, y, z); - // use larger distance for vmap height search than in most other cases - float ground_Z = me->GetMap()->GetHeight(me->GetPhaseMask(), x, y, z, true, MAX_FALL_DISTANCE); - if (fabs(ground_Z - z) < 0.1f) - return; - me->GetMotionMaster()->MoveFall(); } diff --git a/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel_teleport.cpp b/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel_teleport.cpp index 0266db5f2..af8aba57a 100755 --- a/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel_teleport.cpp +++ b/src/server/scripts/Northrend/IcecrownCitadel/icecrown_citadel_teleport.cpp @@ -84,7 +84,7 @@ class at_frozen_throne_teleport : public AreaTriggerScript Spell::SendCastResult(player, spell, 0, SPELL_FAILED_AFFECTING_COMBAT); return true; } - + if (InstanceScript* instance = player->GetInstanceScript()) if (instance->GetBossState(DATA_PROFESSOR_PUTRICIDE) == DONE && instance->GetBossState(DATA_BLOOD_QUEEN_LANA_THEL) == DONE && diff --git a/src/server/scripts/Northrend/Naxxramas/boss_thaddius.cpp b/src/server/scripts/Northrend/Naxxramas/boss_thaddius.cpp index 7977fa4df..e64099da3 100644 --- a/src/server/scripts/Northrend/Naxxramas/boss_thaddius.cpp +++ b/src/server/scripts/Northrend/Naxxramas/boss_thaddius.cpp @@ -15,7 +15,10 @@ * with this program. If not, see . */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "ScriptedCreature.h" +#include "SpellScript.h" + #include "naxxramas.h" //Stalagg @@ -87,7 +90,9 @@ enum ThaddiusSpells SPELL_POSITIVE_CHARGE = 28062, SPELL_POSITIVE_CHARGE_STACK = 29659, SPELL_NEGATIVE_CHARGE = 28085, - SPELL_NEGATIVE_CHARGE_STACK = 29660 + SPELL_NEGATIVE_CHARGE_STACK = 29660, + SPELL_POSITIVE_POLARITY = 28059, + SPELL_NEGATIVE_POLARITY = 28084, }; enum Events @@ -503,6 +508,41 @@ class spell_thaddius_pos_neg_charge : public SpellScriptLoader } }; +class spell_thaddius_polarity_shift : public SpellScriptLoader +{ + public: + spell_thaddius_polarity_shift() : SpellScriptLoader("spell_thaddius_polarity_shift") { } + + class spell_thaddius_polarity_shift_SpellScript : public SpellScript + { + PrepareSpellScript(spell_thaddius_polarity_shift_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_POSITIVE_POLARITY) || !sSpellMgr->GetSpellInfo(SPELL_NEGATIVE_POLARITY)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + target->CastSpell(target, roll_chance_i(50) ? SPELL_POSITIVE_POLARITY : SPELL_NEGATIVE_POLARITY, true, NULL, NULL, caster->GetGUID()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_thaddius_polarity_shift_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_thaddius_polarity_shift_SpellScript(); + } +}; + class achievement_polarity_switch : public AchievementCriteriaScript { public: @@ -520,5 +560,6 @@ void AddSC_boss_thaddius() new mob_stalagg(); new mob_feugen(); new spell_thaddius_pos_neg_charge(); + new spell_thaddius_polarity_shift(); new achievement_polarity_switch(); } diff --git a/src/server/scripts/Northrend/Nexus/EyeOfEternity/boss_malygos.cpp b/src/server/scripts/Northrend/Nexus/EyeOfEternity/boss_malygos.cpp index 6dfa62df2..437d9980a 100644 --- a/src/server/scripts/Northrend/Nexus/EyeOfEternity/boss_malygos.cpp +++ b/src/server/scripts/Northrend/Nexus/EyeOfEternity/boss_malygos.cpp @@ -31,7 +31,6 @@ Script Data End */ #include "eye_of_eternity.h" #include "ScriptedEscortAI.h" -// not implemented enum Achievements { ACHIEV_TIMED_START_EVENT = 20387, @@ -242,6 +241,9 @@ public: _cannotMove = true; me->SetFlying(true); + + if (instance) + instance->DoStopTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT); } uint32 GetData(uint32 data) @@ -359,7 +361,10 @@ public: Talk(SAY_AGGRO_P_ONE); - DoCast(SPELL_BERSEKER); + DoCast(SPELL_BERSEKER); // periodic aura, first tick in 10 minutes + + if (instance) + instance->DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_EVENT, ACHIEV_TIMED_START_EVENT); } void KilledUnit(Unit* who) diff --git a/src/server/scripts/Northrend/Nexus/Oculus/boss_urom.cpp b/src/server/scripts/Northrend/Nexus/Oculus/boss_urom.cpp index aef959aad..9671d59bc 100644 --- a/src/server/scripts/Northrend/Nexus/Oculus/boss_urom.cpp +++ b/src/server/scripts/Northrend/Nexus/Oculus/boss_urom.cpp @@ -289,7 +289,7 @@ public: void JustDied(Unit* /*killer*/) { _JustDied(); - DoCast(me, SPELL_DEATH_SPELL, true); // we cast the spell as triggered or the summon effect does not occur + DoCast(me, SPELL_DEATH_SPELL, true); // we cast the spell as triggered or the summon effect does not occur } void LeaveCombat() diff --git a/src/server/scripts/Northrend/Nexus/Oculus/oculus.cpp b/src/server/scripts/Northrend/Nexus/Oculus/oculus.cpp index c687aad8b..11433bfde 100644 --- a/src/server/scripts/Northrend/Nexus/Oculus/oculus.cpp +++ b/src/server/scripts/Northrend/Nexus/Oculus/oculus.cpp @@ -201,7 +201,7 @@ public: Talk(SAY_UROM); me->DespawnOrUnsummon(60000); } - } + } }; CreatureAI* GetAI(Creature* creature) const diff --git a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp index 2bc2284a2..da46d016e 100644 --- a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp +++ b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_flame_leviathan.cpp @@ -34,6 +34,7 @@ #include "Vehicle.h" #include "VehicleDefines.h" #include "ulduar.h" +#include "Spell.h" enum Spells { @@ -1669,7 +1670,7 @@ class spell_pursue : public SpellScriptLoader if (Creature* caster = GetCaster()->ToCreature()) caster->AI()->EnterEvadeMode(); } - else + else { //! In the end, only one target should be selected _target = SelectRandomContainerElement(targets); @@ -1718,6 +1719,67 @@ class spell_pursue : public SpellScriptLoader } }; +class spell_vehicle_throw_passenger : public SpellScriptLoader +{ + public: + spell_vehicle_throw_passenger() : SpellScriptLoader("spell_vehicle_throw_passenger") {} + + class spell_vehicle_throw_passenger_SpellScript : public SpellScript + { + PrepareSpellScript(spell_vehicle_throw_passenger_SpellScript); + void HandleScript(SpellEffIndex effIndex) + { + Spell* baseSpell = GetSpell(); + SpellCastTargets targets = baseSpell->m_targets; + int32 damage = GetEffectValue(); + if (targets.HasTraj()) + if (Vehicle* vehicle = GetCaster()->GetVehicleKit()) + if (Unit* passenger = vehicle->GetPassenger(damage - 1)) + { + std::list unitList; + // use 99 because it is 3d search + SearchAreaTarget(unitList, 99, PUSH_DST_CENTER, SPELL_TARGETS_ENTRY, NPC_SEAT); + float minDist = 99 * 99; + Unit* target = NULL; + for (std::list::iterator itr = unitList.begin(); itr != unitList.end(); ++itr) + { + if (Vehicle* seat = (*itr)->GetVehicleKit()) + if (!seat->GetPassenger(0)) + if (Unit* device = seat->GetPassenger(2)) + if (!device->GetCurrentSpell(CURRENT_CHANNELED_SPELL)) + { + float dist = (*itr)->GetExactDistSq(targets.GetDst()); + if (dist < minDist) + { + minDist = dist; + target = (*itr); + } + } + } + if (target && target->IsWithinDist2d(targets.GetDst(), GetSpellInfo()->Effects[effIndex].CalcRadius() * 2)) // now we use *2 because the location of the seat is not correct + passenger->EnterVehicle(target, 0); + else + { + passenger->ExitVehicle(); + float x, y, z; + targets.GetDst()->GetPosition(x, y, z); + passenger->GetMotionMaster()->MoveJump(x, y, z, targets.GetSpeedXY(), targets.GetSpeedZ()); + } + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_vehicle_throw_passenger_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_vehicle_throw_passenger_SpellScript(); + } +}; + void AddSC_boss_flame_leviathan() { new boss_flame_leviathan(); @@ -1752,4 +1814,5 @@ void AddSC_boss_flame_leviathan() new spell_auto_repair(); new spell_systems_shutdown(); new spell_pursue(); + new spell_vehicle_throw_passenger(); } diff --git a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_freya.cpp b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_freya.cpp index 12d953a07..159e2a970 100644 --- a/src/server/scripts/Northrend/Ulduar/Ulduar/boss_freya.cpp +++ b/src/server/scripts/Northrend/Ulduar/Ulduar/boss_freya.cpp @@ -593,7 +593,7 @@ class boss_freya : public CreatureScript void JustDied(Unit* /*who*/) { //! Freya's chest is dynamically spawned on death by different spells. - const uint32 summonSpell[2][4] = + const uint32 summonSpell[2][4] = { /* 0Elder, 1Elder, 2Elder, 3Elder */ /* 10N */ {62950, 62953, 62955, 62957}, diff --git a/src/server/scripts/Northrend/UtgardeKeep/UtgardeKeep/boss_keleseth.cpp b/src/server/scripts/Northrend/UtgardeKeep/UtgardeKeep/boss_keleseth.cpp index 8a6d7f808..93cc94923 100644 --- a/src/server/scripts/Northrend/UtgardeKeep/UtgardeKeep/boss_keleseth.cpp +++ b/src/server/scripts/Northrend/UtgardeKeep/UtgardeKeep/boss_keleseth.cpp @@ -18,7 +18,7 @@ /* ScriptData SDName: Boss_Prince_Keleseth SD%Complete: 100 -SDComment: +SDComment: SDCategory: Utgarde Keep EndScriptData */ @@ -158,7 +158,7 @@ public: { if (data == DATA_ON_THE_ROCKS) return onTheRocks; - + return 0; } diff --git a/src/server/scripts/Northrend/UtgardeKeep/UtgardePinnacle/boss_svala.cpp b/src/server/scripts/Northrend/UtgardeKeep/UtgardePinnacle/boss_svala.cpp index 989e1e574..915ead98b 100644 --- a/src/server/scripts/Northrend/UtgardeKeep/UtgardePinnacle/boss_svala.cpp +++ b/src/server/scripts/Northrend/UtgardeKeep/UtgardePinnacle/boss_svala.cpp @@ -34,7 +34,7 @@ enum Spells SPELL_RITUAL_DISARM = 54159, SPELL_RITUAL_STRIKE_EFF_1 = 48277, SPELL_RITUAL_STRIKE_EFF_2 = 59930, - + SPELL_SUMMONED_VIS = 64446, SPELL_RITUAL_CHANNELER_1 = 48271, SPELL_RITUAL_CHANNELER_2 = 48274, @@ -62,7 +62,7 @@ enum Yells SAY_SLAY = 3, SAY_DEATH = 4, SAY_SACRIFICE_PLAYER = 5, - + // Image of Arthas SAY_DIALOG_OF_ARTHAS_1 = 0, SAY_DIALOG_OF_ARTHAS_2 = 1 @@ -101,7 +101,7 @@ enum SvalaPoint #define DATA_INCREDIBLE_HULK 2043 -static const float spectatorWP[2][3] = +static const float spectatorWP[2][3] = { {296.95f,-312.76f,86.36f}, {297.69f,-275.81f,86.36f} @@ -133,7 +133,7 @@ public: InstanceScript* instance; SummonList summons; SvalaPhase Phase; - + Position pos; float x, y, z; @@ -157,7 +157,7 @@ public: summons.DespawnAll(); me->RemoveAllAuras(); - + if (Phase > INTRO) { me->SetFlying(true); @@ -177,7 +177,7 @@ public: instance->SetData64(DATA_SACRIFICED_PLAYER, 0); } } - + void JustReachedHome() { if (Phase > INTRO) @@ -188,23 +188,23 @@ public: me->SendMovementFlagUpdate(); } } - + void EnterCombat(Unit* /*who*/) { Talk(SAY_AGGRO); - + sinsterStrikeTimer = 7 * IN_MILLISECONDS; callFlamesTimer = urand(10 * IN_MILLISECONDS, 20 * IN_MILLISECONDS); if (instance) instance->SetData(DATA_SVALA_SORROWGRAVE_EVENT, IN_PROGRESS); } - + void JustSummoned(Creature* summon) { if (summon->GetEntry() == CREATURE_RITUAL_CHANNELER) summon->CastSpell(summon, SPELL_SUMMONED_VIS, true); - + summons.Summon(summon); } @@ -222,7 +222,7 @@ public: { Phase = INTRO; me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE); - + if (GameObject* mirror = GetClosestGameObjectWithEntry(me, OBJECT_UTGARDE_MIRROR, 100.0f)) mirror->SetGoState(GO_STATE_READY); @@ -233,13 +233,13 @@ public: } } } - + void KilledUnit(Unit* victim) { if (victim != me) Talk(SAY_SLAY); } - + void DamageTaken(Unit* attacker, uint32 &damage) { if (Phase == SVALADEAD) @@ -532,7 +532,7 @@ public: if (IsHeroic()) DoCast(me, SPELL_SHADOWS_IN_THE_DARK); } - + void UpdateAI(const uint32 diff) { if (me->HasUnitState(UNIT_STATE_CASTING)) @@ -648,7 +648,7 @@ class npc_scourge_hulk : public CreatureScript { return type == DATA_INCREDIBLE_HULK ? killedByRitualStrike : 0; } - + void DamageTaken(Unit* attacker, uint32 &damage) { if (damage >= me->GetHealth() && attacker->GetEntry() == CREATURE_SVALA_SORROWGRAVE) diff --git a/src/server/scripts/Northrend/dalaran.cpp b/src/server/scripts/Northrend/dalaran.cpp index cd3cbf29d..258d038ee 100644 --- a/src/server/scripts/Northrend/dalaran.cpp +++ b/src/server/scripts/Northrend/dalaran.cpp @@ -75,7 +75,7 @@ public: return; Player* player = who->GetCharmerOrOwnerPlayerOrPlayerItself(); - + if (!player || player->isGameMaster() || player->IsBeingTeleported() || // If player has Disguise aura for quest A Meeting With The Magister or An Audience With The Arcanist, do not teleport it away but let it pass player->HasAura(SPELL_SUNREAVER_DISGUISE_FEMALE) || player->HasAura(SPELL_SUNREAVER_DISGUISE_MALE) || diff --git a/src/server/scripts/Northrend/sholazar_basin.cpp b/src/server/scripts/Northrend/sholazar_basin.cpp index 79e8da6fd..36dc6177f 100644 --- a/src/server/scripts/Northrend/sholazar_basin.cpp +++ b/src/server/scripts/Northrend/sholazar_basin.cpp @@ -676,7 +676,7 @@ enum MiscLifewarden NPC_SERVANT = 28320, // Servant of Freya WHISPER_ACTIVATE = 0, - + SPELL_FREYA_DUMMY = 51318, SPELL_LIFEFORCE = 51395, SPELL_FREYA_DUMMY_TRIGGER = 51335, diff --git a/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp b/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp index 218c5a122..05fad24f3 100644 --- a/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp +++ b/src/server/scripts/Outland/TempestKeep/Eye/boss_astromancer.cpp @@ -23,7 +23,10 @@ SDComment: SDCategory: Tempest Keep, The Eye EndScriptData */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "ScriptedCreature.h" +#include "SpellScript.h" + #include "the_eye.h" enum eEnums @@ -40,6 +43,7 @@ enum eEnums SPELL_ARCANE_MISSILES = 33031, SPELL_WRATH_OF_THE_ASTROMANCER = 42783, + SPELL_WRATH_OF_THE_ASTROMANCER_DOT = 42784, SPELL_BLINDING_LIGHT = 33009, SPELL_FEAR = 34322, SPELL_VOID_BOLT = 39329, @@ -491,9 +495,74 @@ class mob_solarium_priest : public CreatureScript return new mob_solarium_priestAI (Creature); } }; + +class spell_astromancer_wrath_of_the_astromancer : public SpellScriptLoader +{ + public: + spell_astromancer_wrath_of_the_astromancer() : SpellScriptLoader("spell_astromancer_wrath_of_the_astromancer") { } + + class spell_astromancer_wrath_of_the_astromancer_SpellScript : public SpellScript + { + PrepareSpellScript(spell_astromancer_wrath_of_the_astromancer_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_WRATH_OF_THE_ASTROMANCER_DOT)) + return false; + return true; + } + + bool Load() + { + _targetCount = 0; + return true; + } + + void CountTargets(std::list& targetList) + { + _targetCount = targetList.size(); + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (Unit* caster = GetOriginalCaster()) + if (Unit* target = GetHitUnit()) + { + if (!target->isAlive() || !_targetCount) + return; + + int32 damage = 10000 / _targetCount; + + SpellNonMeleeDamage damageInfo(caster, target, GetSpellInfo()->Id, GetSpellInfo()->SchoolMask); + damageInfo.damage = damage; + + caster->CalcAbsorbResist(target, GetSpellInfo()->GetSchoolMask(), DOT, damage, &damageInfo.absorb, &damageInfo.resist, GetSpellInfo()); + caster->DealDamageMods(target, damageInfo.damage, &damageInfo.absorb); + caster->SendSpellNonMeleeDamageLog(&damageInfo); + caster->DealSpellDamage(&damageInfo, false); + } + } + + private: + int32 _targetCount; + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_astromancer_wrath_of_the_astromancer_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + OnUnitTargetSelect += SpellUnitTargetFn(spell_astromancer_wrath_of_the_astromancer_SpellScript::CountTargets, EFFECT_0, TARGET_DEST_CASTER_RADIUS); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_astromancer_wrath_of_the_astromancer_SpellScript(); + } +}; + void AddSC_boss_high_astromancer_solarian() { new boss_high_astromancer_solarian(); new mob_solarium_priest(); + new spell_astromancer_wrath_of_the_astromancer(); } diff --git a/src/server/scripts/Outland/TempestKeep/Mechanar/boss_mechano_lord_capacitus.cpp b/src/server/scripts/Outland/TempestKeep/Mechanar/boss_mechano_lord_capacitus.cpp index ed818fb13..3579a7d69 100644 --- a/src/server/scripts/Outland/TempestKeep/Mechanar/boss_mechano_lord_capacitus.cpp +++ b/src/server/scripts/Outland/TempestKeep/Mechanar/boss_mechano_lord_capacitus.cpp @@ -22,20 +22,22 @@ enum Spells { - SPELL_POSITIVE_CHARGE = 39090, + SPELL_POSITIVE_POLARITY = 39088, SPELL_POSITIVE_CHARGE_STACK = 39089, + SPELL_POSITIVE_CHARGE = 39090, + SPELL_NEGATIVE_POLARITY = 39091, + SPELL_NEGATIVE_CHARGE_STACK = 39092, SPELL_NEGATIVE_CHARGE = 39093, - SPELL_NEGATIVE_CHARGE_STACK = 39092 }; -class spell_capacitus_polarity_shift : public SpellScriptLoader +class spell_capacitus_polarity_charge : public SpellScriptLoader { public: - spell_capacitus_polarity_shift() : SpellScriptLoader("spell_capacitus_polarity_shift") { } + spell_capacitus_polarity_charge() : SpellScriptLoader("spell_capacitus_polarity_charge") { } - class spell_capacitus_polarity_shift_SpellScript : public SpellScript + class spell_capacitus_polarity_charge_SpellScript : public SpellScript { - PrepareSpellScript(spell_capacitus_polarity_shift_SpellScript); + PrepareSpellScript(spell_capacitus_polarity_charge_SpellScript); bool Validate(SpellInfo const* /*spell*/) { @@ -85,8 +87,44 @@ class spell_capacitus_polarity_shift : public SpellScriptLoader void Register() { - OnEffectHitTarget += SpellEffectFn(spell_capacitus_polarity_shift_SpellScript::HandleDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); - OnUnitTargetSelect += SpellUnitTargetFn(spell_capacitus_polarity_shift_SpellScript::HandleTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ALLY); + OnEffectHitTarget += SpellEffectFn(spell_capacitus_polarity_charge_SpellScript::HandleDamage, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE); + OnUnitTargetSelect += SpellUnitTargetFn(spell_capacitus_polarity_charge_SpellScript::HandleTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ALLY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_capacitus_polarity_charge_SpellScript(); + } +}; + +class spell_capacitus_polarity_shift : public SpellScriptLoader +{ + public: + spell_capacitus_polarity_shift() : SpellScriptLoader("spell_capacitus_polarity_shift") { } + + class spell_capacitus_polarity_shift_SpellScript : public SpellScript + { + PrepareSpellScript(spell_capacitus_polarity_shift_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_POSITIVE_POLARITY) || !sSpellMgr->GetSpellInfo(SPELL_NEGATIVE_POLARITY)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* target = GetHitUnit(); + Unit* caster = GetCaster(); + + target->CastSpell(target, roll_chance_i(50) ? SPELL_POSITIVE_POLARITY : SPELL_NEGATIVE_POLARITY, true, NULL, NULL, caster->GetGUID()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_capacitus_polarity_shift_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); } }; @@ -98,5 +136,6 @@ class spell_capacitus_polarity_shift : public SpellScriptLoader void AddSC_boss_mechano_lord_capacitus() { + new spell_capacitus_polarity_charge(); new spell_capacitus_polarity_shift(); } diff --git a/src/server/scripts/Outland/blades_edge_mountains.cpp b/src/server/scripts/Outland/blades_edge_mountains.cpp index 97ce9f454..f99851f01 100644 --- a/src/server/scripts/Outland/blades_edge_mountains.cpp +++ b/src/server/scripts/Outland/blades_edge_mountains.cpp @@ -739,7 +739,7 @@ class npc_simon_bunny : public CreatureScript if (!listening) return; - uint8 pressedColor; + uint8 pressedColor = SIMON_MAX_COLORS; if (type == clusterIds[SIMON_RED]) pressedColor = SIMON_RED; @@ -974,10 +974,10 @@ class npc_simon_bunny : public CreatureScript // Handles the spell rewards. The spells also have the QuestCompleteEffect, so quests credits are working. void GiveRewardForLevel(uint8 level) { - uint32 rewSpell; + uint32 rewSpell = 0; switch (level) { - case 6: + case 6: if (large) GivePunishment(); else @@ -989,8 +989,6 @@ class npc_simon_bunny : public CreatureScript case 10: rewSpell = SPELL_REWARD_BUFF_3; break; - default: - rewSpell = 0; } if (rewSpell) diff --git a/src/server/scripts/Spells/spell_dk.cpp b/src/server/scripts/Spells/spell_dk.cpp index 5c0f6bcce..92fae4e12 100644 --- a/src/server/scripts/Spells/spell_dk.cpp +++ b/src/server/scripts/Spells/spell_dk.cpp @@ -21,8 +21,9 @@ * Scriptnames of files in this file should be prefixed with "spell_dk_". */ -#include "ScriptPCH.h" -#include "Spell.h" +#include "ScriptMgr.h" +#include "SpellScript.h" +#include "SpellAuraEffects.h" enum DeathKnightSpells { @@ -103,7 +104,9 @@ class spell_dk_anti_magic_shell_self : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - return sSpellMgr->GetSpellInfo(DK_SPELL_RUNIC_POWER_ENERGIZE); + if (!sSpellMgr->GetSpellInfo(DK_SPELL_RUNIC_POWER_ENERGIZE)) + return false; + return true; } void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) @@ -160,17 +163,16 @@ class spell_dk_anti_magic_zone : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - return sSpellMgr->GetSpellInfo(DK_SPELL_ANTI_MAGIC_SHELL_TALENT); + if (!sSpellMgr->GetSpellInfo(DK_SPELL_ANTI_MAGIC_SHELL_TALENT)) + return false; + return true; } void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) { SpellInfo const* talentSpell = sSpellMgr->GetSpellInfo(DK_SPELL_ANTI_MAGIC_SHELL_TALENT); amount = talentSpell->Effects[EFFECT_0].CalcValue(GetCaster()); - Unit* caster = GetCaster(); - if (!caster) - return; - if (Player* player = caster->ToPlayer()) + if (Player* player = GetCaster()->ToPlayer()) amount += int32(2 * player->GetTotalAttackPowerValue(BASE_ATTACK)); } @@ -204,9 +206,7 @@ class spell_dk_corpse_explosion : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(DK_SPELL_CORPSE_EXPLOSION_TRIGGERED)) - return false; - if (!sSpellMgr->GetSpellInfo(DK_SPELL_GHOUL_EXPLODE)) + if (!sSpellMgr->GetSpellInfo(DK_SPELL_CORPSE_EXPLOSION_TRIGGERED) || !sSpellMgr->GetSpellInfo(DK_SPELL_GHOUL_EXPLODE)) return false; if (!sSpellMgr->GetSpellInfo(DK_SPELL_CORPSE_EXPLOSION_VISUAL)) return false; @@ -257,6 +257,13 @@ class spell_dk_ghoul_explode : public SpellScriptLoader { PrepareSpellScript(spell_dk_ghoul_explode_SpellScript); + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(DK_SPELL_CORPSE_EXPLOSION_TRIGGERED)) + return false; + return true; + } + void Suicide(SpellEffIndex /*effIndex*/) { if (Unit* unitTarget = GetHitUnit()) @@ -301,9 +308,8 @@ class spell_dk_death_gate : public SpellScriptLoader void HandleScript(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - if (!GetHitUnit()) - return; - GetHitUnit()->CastSpell(GetHitUnit(), GetEffectValue(), false); + if (Unit* target = GetHitUnit()) + target->CastSpell(target, GetEffectValue(), false); } void Register() @@ -567,12 +573,11 @@ public: class spell_dk_improved_blood_presence_AuraScript : public AuraScript { - PrepareAuraScript(spell_dk_improved_blood_presence_AuraScript) + PrepareAuraScript(spell_dk_improved_blood_presence_AuraScript); + bool Validate(SpellInfo const* /*entry*/) { - if (!sSpellMgr->GetSpellInfo(DK_SPELL_BLOOD_PRESENCE)) - return false; - if (!sSpellMgr->GetSpellInfo(DK_SPELL_IMPROVED_BLOOD_PRESENCE_TRIGGERED)) + if (!sSpellMgr->GetSpellInfo(DK_SPELL_BLOOD_PRESENCE) || !sSpellMgr->GetSpellInfo(DK_SPELL_IMPROVED_BLOOD_PRESENCE_TRIGGERED)) return false; return true; } @@ -615,12 +620,11 @@ public: class spell_dk_improved_unholy_presence_AuraScript : public AuraScript { - PrepareAuraScript(spell_dk_improved_unholy_presence_AuraScript) + PrepareAuraScript(spell_dk_improved_unholy_presence_AuraScript); + bool Validate(SpellInfo const* /*entry*/) { - if (!sSpellMgr->GetSpellInfo(DK_SPELL_UNHOLY_PRESENCE)) - return false; - if (!sSpellMgr->GetSpellInfo(DK_SPELL_IMPROVED_UNHOLY_PRESENCE_TRIGGERED)) + if (!sSpellMgr->GetSpellInfo(DK_SPELL_UNHOLY_PRESENCE) || !sSpellMgr->GetSpellInfo(DK_SPELL_IMPROVED_UNHOLY_PRESENCE_TRIGGERED)) return false; return true; } @@ -656,6 +660,141 @@ public: } }; +enum DeathStrike +{ + ICON_ID_IMPROVED_DEATH_STRIKE = 2751, + SPELL_DEATH_STRIKE_HEAL = 45470, +}; + +class spell_dk_death_strike : public SpellScriptLoader +{ + public: + spell_dk_death_strike() : SpellScriptLoader("spell_dk_death_strike") { } + + class spell_dk_death_strike_SpellScript : public SpellScript + { + PrepareSpellScript(spell_dk_death_strike_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DEATH_STRIKE_HEAL)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + { + uint32 count = target->GetDiseasesByCaster(caster->GetGUID()); + int32 bp = int32(count * caster->CountPctFromMaxHealth(int32(GetSpellInfo()->Effects[EFFECT_0].DamageMultiplier))); + // Improved Death Strike + if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_AURA_ADD_PCT_MODIFIER, SPELLFAMILY_DEATHKNIGHT, ICON_ID_IMPROVED_DEATH_STRIKE, 0)) + AddPctN(bp, caster->CalculateSpellDamage(caster, aurEff->GetSpellInfo(), 2)); + caster->CastCustomSpell(caster, SPELL_DEATH_STRIKE_HEAL, &bp, NULL, NULL, false); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_dk_death_strike_SpellScript::HandleDummy, EFFECT_2, SPELL_EFFECT_DUMMY); + } + + }; + + SpellScript* GetSpellScript() const + { + return new spell_dk_death_strike_SpellScript(); + } +}; + +enum DeathCoil +{ + SPELL_DEATH_COIL_DAMAGE = 47632, + SPELL_DEATH_COIL_HEAL = 47633, +}; + +class spell_dk_death_coil : public SpellScriptLoader +{ + public: + spell_dk_death_coil() : SpellScriptLoader("spell_dk_death_coil") { } + + class spell_dk_death_coil_SpellScript : public SpellScript + { + PrepareSpellScript(spell_dk_death_coil_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DEATH_COIL_DAMAGE) || !sSpellMgr->GetSpellInfo(SPELL_DEATH_COIL_HEAL)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + if (caster->IsFriendlyTo(target)) + { + int32 bp = int32(damage * 1.5f); + caster->CastCustomSpell(target, SPELL_DEATH_COIL_HEAL, &bp, NULL, NULL, true); + } + else + caster->CastCustomSpell(target, SPELL_DEATH_COIL_DAMAGE, &damage, NULL, NULL, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_dk_death_coil_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + + }; + + SpellScript* GetSpellScript() const + { + return new spell_dk_death_coil_SpellScript(); + } +}; + +class spell_dk_death_grip : public SpellScriptLoader +{ + public: + spell_dk_death_grip() : SpellScriptLoader("spell_dk_death_grip") { } + + class spell_dk_death_grip_SpellScript : public SpellScript + { + PrepareSpellScript(spell_dk_death_grip_SpellScript); + + void HandleDummy(SpellEffIndex effIndex) + { + int32 damage = GetEffectValue(); + Spell* baseSpell = GetSpell(); + Position pos; + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + { + GetSummonPosition(effIndex, pos, 0.0f, 0); + + if (!target->HasAuraType(SPELL_AURA_DEFLECT_SPELLS)) // Deterrence + target->CastSpell(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), damage, true); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_dk_death_grip_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + + }; + + SpellScript* GetSpellScript() const + { + return new spell_dk_death_grip_SpellScript(); + } +}; + void AddSC_deathknight_spell_scripts() { new spell_dk_anti_magic_shell_raid(); @@ -671,4 +810,7 @@ void AddSC_deathknight_spell_scripts() new spell_dk_will_of_the_necropolis(); new spell_dk_improved_blood_presence(); new spell_dk_improved_unholy_presence(); + new spell_dk_death_strike(); + new spell_dk_death_coil(); + new spell_dk_death_grip(); } diff --git a/src/server/scripts/Spells/spell_druid.cpp b/src/server/scripts/Spells/spell_druid.cpp index 130f61565..4c440f18b 100644 --- a/src/server/scripts/Spells/spell_druid.cpp +++ b/src/server/scripts/Spells/spell_druid.cpp @@ -21,7 +21,8 @@ * Scriptnames of files in this file should be prefixed with "spell_dru_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" enum DruidSpells @@ -42,9 +43,7 @@ class spell_dru_glyph_of_starfire : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(DRUID_INCREASED_MOONFIRE_DURATION)) - return false; - if (!sSpellMgr->GetSpellInfo(DRUID_NATURES_SPLENDOR)) + if (!sSpellMgr->GetSpellInfo(DRUID_INCREASED_MOONFIRE_DURATION) || !sSpellMgr->GetSpellInfo(DRUID_NATURES_SPLENDOR)) return false; return true; } @@ -305,14 +304,16 @@ class spell_dru_swift_flight_passive : public SpellScriptLoader { PrepareAuraScript(spell_dru_swift_flight_passive_AuraScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) { - Unit* caster = GetCaster(); - if (!caster || !caster->ToPlayer()) - return; - - if (caster->ToPlayer()->Has310Flyer(false)) - amount = 310; + if (Player* caster = GetCaster()->ToPlayer()) + if (caster->Has310Flyer(false)) + amount = 310; } void Register() @@ -327,6 +328,45 @@ class spell_dru_swift_flight_passive : public SpellScriptLoader } }; +class spell_dru_starfall_dummy : public SpellScriptLoader +{ + public: + spell_dru_starfall_dummy() : SpellScriptLoader("spell_dru_starfall_dummy") { } + + class spell_dru_starfall_dummy_SpellScript : public SpellScript + { + PrepareSpellScript(spell_dru_starfall_dummy_SpellScript); + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + // Shapeshifting into an animal form or mounting cancels the effect + if (caster->GetCreatureType() == CREATURE_TYPE_BEAST || caster->IsMounted()) + { + if (SpellInfo const* spellInfo = GetTriggeringSpell()) + caster->RemoveAurasDueToSpell(spellInfo->Id); + return; + } + + //Any effect which causes you to lose control of your character will supress the starfall effect. + if (caster->HasUnitState(UNIT_STATE_CONTROLLED)) + return; + + caster->CastSpell(GetHitUnit(), GetEffectValue(), true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_dru_starfall_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_dru_starfall_dummy_SpellScript(); + } +}; + void AddSC_druid_spell_scripts() { new spell_dru_glyph_of_starfire(); @@ -336,4 +376,5 @@ void AddSC_druid_spell_scripts() new spell_dru_t10_restoration_4p_bonus(); new spell_dru_starfall_aoe(); new spell_dru_swift_flight_passive(); + new spell_dru_starfall_dummy(); } diff --git a/src/server/scripts/Spells/spell_generic.cpp b/src/server/scripts/Spells/spell_generic.cpp index 9899e50cd..638a17bc4 100644 --- a/src/server/scripts/Spells/spell_generic.cpp +++ b/src/server/scripts/Spells/spell_generic.cpp @@ -22,10 +22,15 @@ * Scriptnames of files in this file should be prefixed with "spell_gen_" */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" #include "SkillDiscovery.h" +#include "Cell.h" +#include "CellImpl.h" #include "GridNotifiers.h" +#include "GridNotifiersImpl.h" +#include "InstanceScript.h" #include "Group.h" #include "LFGMgr.h" @@ -236,9 +241,7 @@ class spell_gen_parachute : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_PARACHUTE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_PARACHUTE_BUFF)) + if (!sSpellMgr->GetSpellInfo(SPELL_PARACHUTE) || !sSpellMgr->GetSpellInfo(SPELL_PARACHUTE_BUFF)) return false; return true; } @@ -246,13 +249,11 @@ class spell_gen_parachute : public SpellScriptLoader void HandleEffectPeriodic(AuraEffect const* /*aurEff*/) { if (Player* target = GetTarget()->ToPlayer()) - { if (target->IsFalling()) { target->RemoveAurasDueToSpell(SPELL_PARACHUTE); target->CastSpell(target, SPELL_PARACHUTE_BUFF, true); } - } } void Register() @@ -283,13 +284,14 @@ class spell_gen_pet_summoned : public SpellScriptLoader { PrepareSpellScript(spell_gen_pet_summoned_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleScript(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; - - Player* player = caster->ToPlayer(); + Player* player = GetCaster()->ToPlayer(); if (player->GetLastPetNumber()) { PetType newPetType = (player->getClass() == CLASS_HUNTER) ? HUNTER_PET : SUMMON_PET; @@ -340,10 +342,14 @@ class spell_gen_remove_flight_auras : public SpellScriptLoader class spell_gen_remove_flight_auras_SpellScript : public SpellScript { PrepareSpellScript(spell_gen_remove_flight_auras_SpellScript); + void HandleScript(SpellEffIndex /*effIndex*/) { - GetHitUnit()->RemoveAurasByType(SPELL_AURA_FLY); - GetHitUnit()->RemoveAurasByType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED); + if (Unit* target = GetHitUnit()) + { + target->RemoveAurasByType(SPELL_AURA_FLY); + target->RemoveAurasByType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED); + } } void Register() @@ -376,22 +382,21 @@ class spell_gen_leeching_swarm : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_LEECHING_SWARM_DMG)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_LEECHING_SWARM_HEAL)) + if (!sSpellMgr->GetSpellInfo(SPELL_LEECHING_SWARM_DMG) || !sSpellMgr->GetSpellInfo(SPELL_LEECHING_SWARM_HEAL)) return false; return true; } void HandleEffectPeriodic(AuraEffect const* aurEff) { - if (Unit* caster = GetCaster()) + Unit* caster = GetCaster(); + if (Unit* target = GetTarget()) { - int32 lifeLeeched = GetTarget()->CountPctFromCurHealth(aurEff->GetAmount()); + int32 lifeLeeched = target->CountPctFromCurHealth(aurEff->GetAmount()); if (lifeLeeched < 250) lifeLeeched = 250; // Damage - caster->CastCustomSpell(GetTarget(), SPELL_LEECHING_SWARM_DMG, &lifeLeeched, 0, 0, false); + caster->CastCustomSpell(target, SPELL_LEECHING_SWARM_DMG, &lifeLeeched, 0, 0, false); // Heal caster->CastCustomSpell(caster, SPELL_LEECHING_SWARM_HEAL, &lifeLeeched, 0, 0, false); } @@ -500,31 +505,16 @@ class spell_gen_trick : public SpellScriptLoader PrepareSpellScript(spell_gen_trick_SpellScript); bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_PIRATE_COSTUME_MALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_PIRATE_COSTUME_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NINJA_COSTUME_MALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NINJA_COSTUME_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_LEPER_GNOME_COSTUME_MALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_LEPER_GNOME_COSTUME_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SKELETON_COSTUME)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_GHOST_COSTUME_MALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_GHOST_COSTUME_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_TRICK_BUFF)) + if (!sSpellMgr->GetSpellInfo(SPELL_PIRATE_COSTUME_MALE) || !sSpellMgr->GetSpellInfo(SPELL_PIRATE_COSTUME_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_NINJA_COSTUME_MALE) + || !sSpellMgr->GetSpellInfo(SPELL_NINJA_COSTUME_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_LEPER_GNOME_COSTUME_MALE) || !sSpellMgr->GetSpellInfo(SPELL_LEPER_GNOME_COSTUME_FEMALE) + || !sSpellMgr->GetSpellInfo(SPELL_SKELETON_COSTUME) || !sSpellMgr->GetSpellInfo(SPELL_GHOST_COSTUME_MALE) || !sSpellMgr->GetSpellInfo(SPELL_GHOST_COSTUME_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_TRICK_BUFF)) return false; return true; } void HandleScript(SpellEffIndex /*effIndex*/) { + Unit* caster = GetCaster(); if (Player* target = GetHitPlayer()) { uint8 gender = target->getGender(); @@ -550,7 +540,7 @@ class spell_gen_trick : public SpellScriptLoader break; } - GetCaster()->CastSpell(target, spellId, true, NULL); + caster->CastSpell(target, spellId, true, NULL); } } @@ -585,21 +575,18 @@ class spell_gen_trick_or_treat : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_TRICK)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_TREAT)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_TRICKED_OR_TREATED)) + if (!sSpellMgr->GetSpellInfo(SPELL_TRICK) || !sSpellMgr->GetSpellInfo(SPELL_TREAT) || !sSpellMgr->GetSpellInfo(SPELL_TRICKED_OR_TREATED)) return false; return true; } void HandleScript(SpellEffIndex /*effIndex*/) { + Unit* caster = GetCaster(); if (Player* target = GetHitPlayer()) { - GetCaster()->CastSpell(target, roll_chance_i(50) ? SPELL_TRICK : SPELL_TREAT, true, NULL); - GetCaster()->CastSpell(target, SPELL_TRICKED_OR_TREATED, true, NULL); + caster->CastSpell(target, roll_chance_i(50) ? SPELL_TRICK : SPELL_TREAT, true, NULL); + caster->CastSpell(target, SPELL_TRICKED_OR_TREATED, true, NULL); } } @@ -661,11 +648,14 @@ class spell_pvp_trinket_wotf_shared_cd : public SpellScriptLoader { PrepareSpellScript(spell_pvp_trinket_wotf_shared_cd_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_WILL_OF_THE_FORSAKEN_COOLDOWN_TRIGGER)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_WILL_OF_THE_FORSAKEN_COOLDOWN_TRIGGER_WOTF)) + if (!sSpellMgr->GetSpellInfo(SPELL_WILL_OF_THE_FORSAKEN_COOLDOWN_TRIGGER) || !sSpellMgr->GetSpellInfo(SPELL_WILL_OF_THE_FORSAKEN_COOLDOWN_TRIGGER_WOTF)) return false; return true; } @@ -673,10 +663,7 @@ class spell_pvp_trinket_wotf_shared_cd : public SpellScriptLoader void HandleScript(SpellEffIndex /*effIndex*/) { Player* caster = GetCaster()->ToPlayer(); - if (!caster) - return; SpellInfo const* spellInfo = GetSpellInfo(); - caster->AddSpellCooldown(spellInfo->Id, 0, time(NULL) + sSpellMgr->GetSpellInfo(SPELL_WILL_OF_THE_FORSAKEN_COOLDOWN_TRIGGER)->GetRecoveryTime() / IN_MILLISECONDS); WorldPacket data(SMSG_SPELL_COOLDOWN, 8+1+4); data << uint64(caster->GetGUID()); @@ -729,8 +716,9 @@ class spell_gen_animal_blood : public SpellScriptLoader void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { - if (GetUnitOwner()->IsInWater()) - GetUnitOwner()->CastSpell(GetUnitOwner(), SPELL_SPAWN_BLOOD_POOL, true); + if (Unit* owner = GetUnitOwner()) + if (owner->IsInWater()) + owner->CastSpell(owner, SPELL_SPAWN_BLOOD_POOL, true); } void Register() @@ -761,6 +749,11 @@ class spell_gen_divine_storm_cd_reset : public SpellScriptLoader { PrepareSpellScript(spell_gen_divine_storm_cd_reset_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + bool Validate(SpellInfo const* /*spellEntry*/) { if (!sSpellMgr->GetSpellInfo(SPELL_DIVINE_STORM)) @@ -770,9 +763,9 @@ class spell_gen_divine_storm_cd_reset : public SpellScriptLoader void HandleScript(SpellEffIndex /*effIndex*/) { - if (Player* caster = GetCaster()->ToPlayer()) - if (caster->HasSpellCooldown(SPELL_DIVINE_STORM)) - caster->RemoveSpellCooldown(SPELL_DIVINE_STORM, true); + Player* caster = GetCaster()->ToPlayer(); + if (caster->HasSpellCooldown(SPELL_DIVINE_STORM)) + caster->RemoveSpellCooldown(SPELL_DIVINE_STORM, true); } void Register() @@ -796,13 +789,15 @@ class spell_gen_gunship_portal : public SpellScriptLoader { PrepareSpellScript(spell_gen_gunship_portal_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleScript(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; - - if (Battleground* bg = caster->ToPlayer()->GetBattleground()) + Player* caster = GetCaster()->ToPlayer(); + if (Battleground* bg = caster->GetBattleground()) if (bg->GetTypeID(true) == BATTLEGROUND_IC) bg->DoAction(1, caster->GetGUID()); } @@ -821,7 +816,7 @@ class spell_gen_gunship_portal : public SpellScriptLoader enum parachuteIC { - SPELL_PARACHUTE_IC = 66657 + SPELL_PARACHUTE_IC = 66657, }; class spell_gen_parachute_ic : public SpellScriptLoader @@ -835,13 +830,9 @@ class spell_gen_parachute_ic : public SpellScriptLoader void HandleTriggerSpell(AuraEffect const* /*aurEff*/) { - Unit* target = GetTarget(); - - if (!target->ToPlayer()) - return; - - if (target->ToPlayer()->m_movementInfo.fallTime > 2000) - target->CastSpell(target, SPELL_PARACHUTE_IC, true); + if (Player* target = GetTarget()->ToPlayer()) + if (target->m_movementInfo.fallTime > 2000) + target->CastSpell(target, SPELL_PARACHUTE_IC, true); } void Register() @@ -868,7 +859,7 @@ class spell_gen_dungeon_credit : public SpellScriptLoader bool Load() { _handled = false; - return true; + return GetCaster()->GetTypeId() == TYPEID_UNIT; } void CreditEncounter() @@ -878,9 +869,9 @@ class spell_gen_dungeon_credit : public SpellScriptLoader return; _handled = true; - if (GetCaster()->GetTypeId() == TYPEID_UNIT) - if (InstanceScript* instance = GetCaster()->GetInstanceScript()) - instance->UpdateEncounterState(ENCOUNTER_CREDIT_CAST_SPELL, GetSpellInfo()->Id, GetCaster()); + Unit* caster = GetCaster(); + if (InstanceScript* instance = caster->GetInstanceScript()) + instance->UpdateEncounterState(ENCOUNTER_CREDIT_CAST_SPELL, GetSpellInfo()->Id, caster); } void Register() @@ -906,9 +897,14 @@ class spell_gen_profession_research : public SpellScriptLoader { PrepareSpellScript(spell_gen_profession_research_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + SpellCastResult CheckRequirement() { - if (GetCaster()->GetTypeId() == TYPEID_PLAYER && HasDiscoveredAllSpells(GetSpellInfo()->Id, GetCaster()->ToPlayer())) + if (HasDiscoveredAllSpells(GetSpellInfo()->Id, GetCaster()->ToPlayer())) { SetCustomCastResultMessage(SPELL_CUSTOM_ERROR_NOTHING_TO_DISCOVER); return SPELL_FAILED_CUSTOM_ERROR; @@ -978,19 +974,11 @@ class spell_generic_clone_weapon : public SpellScriptLoader class spell_generic_clone_weapon_SpellScript : public SpellScript { PrepareSpellScript(spell_generic_clone_weapon_SpellScript); + bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON_2)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON_3)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_OFFHAND)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_OFFHAND_2)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_COPY_RANGED)) + if (!sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON) || !sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON_2) || !sSpellMgr->GetSpellInfo(SPELL_COPY_WEAPON_3) || !sSpellMgr->GetSpellInfo(SPELL_COPY_OFFHAND) + || !sSpellMgr->GetSpellInfo(SPELL_COPY_OFFHAND_2) || !sSpellMgr->GetSpellInfo(SPELL_COPY_RANGED)) return false; return true; } @@ -999,57 +987,56 @@ class spell_generic_clone_weapon : public SpellScriptLoader { PreventHitDefaultEffect(effIndex); Unit* caster = GetCaster(); - Unit* target = GetHitUnit(); - - if (!target) - return; - - uint32 spellId = uint32(GetSpellInfo()->Effects[EFFECT_0].CalcValue()); - target->CastSpell(caster, spellId, true); - - if (target->GetTypeId() == TYPEID_PLAYER) - return; - - switch (GetSpellInfo()->Id) + if (Unit* target = GetHitUnit()) { - case SPELL_COPY_WEAPON: - case SPELL_COPY_WEAPON_2: - case SPELL_COPY_WEAPON_3: + + uint32 spellId = uint32(GetSpellInfo()->Effects[EFFECT_0].CalcValue()); + target->CastSpell(caster, spellId, true); + + if (target->GetTypeId() == TYPEID_PLAYER) + return; + + switch (GetSpellInfo()->Id) { - if (Player* player = caster->ToPlayer()) + case SPELL_COPY_WEAPON: + case SPELL_COPY_WEAPON_2: + case SPELL_COPY_WEAPON_3: { - if (Item* mainItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND)) - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, mainItem->GetEntry()); + if (Player* player = caster->ToPlayer()) + { + if (Item* mainItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND)) + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, mainItem->GetEntry()); + } + else + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID)); + break; } - else - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID)); - break; - } - case SPELL_COPY_OFFHAND: - case SPELL_COPY_OFFHAND_2: - { - if (Player* player = caster->ToPlayer()) + case SPELL_COPY_OFFHAND: + case SPELL_COPY_OFFHAND_2: { - if (Item* offItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND)) - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, offItem->GetEntry()); + if (Player* player = caster->ToPlayer()) + { + if (Item* offItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND)) + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, offItem->GetEntry()); + } + else + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1)); + break; } - else - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1)); - break; - } - case SPELL_COPY_RANGED: - { - if (Player* player = caster->ToPlayer()) + case SPELL_COPY_RANGED: { - if (Item* rangedItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED)) - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, rangedItem->GetEntry()); + if (Player* player = caster->ToPlayer()) + { + if (Item* rangedItem = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_RANGED)) + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, rangedItem->GetEntry()); + } + else + target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2)); + break; } - else - target->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, caster->GetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2)); - break; + default: + break; } - default: - break; } } @@ -1095,10 +1082,10 @@ class spell_gen_seaforium_blast : public SpellScriptLoader void AchievementCredit(SpellEffIndex /*effIndex*/) { // but in effect handling OriginalCaster can become NULL - if (!GetOriginalCaster() || !GetHitGObj() || GetHitGObj()->GetGOInfo()->type != GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING) - return; - - GetOriginalCaster()->CastSpell(GetOriginalCaster(), SPELL_PLANT_CHARGES_CREDIT_ACHIEVEMENT, true); + if (Unit* originalCaster = GetOriginalCaster()) + if (GameObject* go = GetHitGObj()) + if (GetHitGObj()->GetGOInfo()->type == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING) + originalCaster->CastSpell(originalCaster, SPELL_PLANT_CHARGES_CREDIT_ACHIEVEMENT, true); } void Register() @@ -1131,10 +1118,11 @@ class spell_gen_turkey_marker : public SpellScriptLoader { // store stack apply times, so we can pop them while they expire _applyTimes.push_back(getMSTime()); + Unit* target = GetTarget(); // on stack 15 cast the achievement crediting spell if (GetStackAmount() >= 15) - GetTarget()->CastSpell(GetTarget(), SPELL_TURKEY_VENGEANCE, true, NULL, aurEff, GetCasterGUID()); + target->CastSpell(target, SPELL_TURKEY_VENGEANCE, true, NULL, aurEff, GetCasterGUID()); } void OnPeriodic(AuraEffect const* /*aurEff*/) @@ -1208,29 +1196,28 @@ class spell_gen_magic_rooster : public SpellScriptLoader void HandleScript(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - Player* target = GetHitPlayer(); - if (!target) - return; - - // prevent client crashes from stacking mounts - target->RemoveAurasByType(SPELL_AURA_MOUNTED); - - uint32 spellId = SPELL_MAGIC_ROOSTER_NORMAL; - switch (target->getRace()) + if (Player* target = GetHitPlayer()) { - case RACE_DRAENEI: - if (target->getGender() == GENDER_MALE) - spellId = SPELL_MAGIC_ROOSTER_DRAENEI_MALE; - break; - case RACE_TAUREN: - if (target->getGender() == GENDER_MALE) - spellId = SPELL_MAGIC_ROOSTER_TAUREN_MALE; - break; - default: - break; - } + // prevent client crashes from stacking mounts + target->RemoveAurasByType(SPELL_AURA_MOUNTED); - target->CastSpell(target, spellId, true); + uint32 spellId = SPELL_MAGIC_ROOSTER_NORMAL; + switch (target->getRace()) + { + case RACE_DRAENEI: + if (target->getGender() == GENDER_MALE) + spellId = SPELL_MAGIC_ROOSTER_DRAENEI_MALE; + break; + case RACE_TAUREN: + if (target->getGender() == GENDER_MALE) + spellId = SPELL_MAGIC_ROOSTER_TAUREN_MALE; + break; + default: + break; + } + + target->CastSpell(target, spellId, true); + } } void Register() @@ -1258,7 +1245,6 @@ public: { if (!GetCastItem()) return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW; - return SPELL_CAST_OK; } @@ -1335,12 +1321,14 @@ class spell_gen_vehicle_scaling : public SpellScriptLoader { PrepareAuraScript(spell_gen_vehicle_scaling_AuraScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void CalculateAmount(AuraEffect const* /*aurEff*/, int32& amount, bool& /*canBeRecalculated*/) { Unit* caster = GetCaster(); - if (!caster || !caster->ToPlayer()) - return; - float factor; uint16 baseItemLevel; @@ -1379,21 +1367,23 @@ class spell_gen_vehicle_scaling : public SpellScriptLoader }; -class spell_gen_oracle_wolvar_reputation: public SpellScriptLoader +class spell_gen_oracle_wolvar_reputation : public SpellScriptLoader { -public: - spell_gen_oracle_wolvar_reputation() : SpellScriptLoader("spell_gen_oracle_wolvar_reputation") { } + public: + spell_gen_oracle_wolvar_reputation() : SpellScriptLoader("spell_gen_oracle_wolvar_reputation") { } - class spell_gen_oracle_wolvar_reputation_SpellScript : public SpellScript - { - PrepareSpellScript(spell_gen_oracle_wolvar_reputation_SpellScript) - - void HandleDummy(SpellEffIndex effIndex) + class spell_gen_oracle_wolvar_reputation_SpellScript : public SpellScript { + PrepareSpellScript(spell_gen_oracle_wolvar_reputation_SpellScript); - if (Player* player = GetCaster()->ToPlayer()) + bool Load() { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleDummy(SpellEffIndex effIndex) + { + Player* player = GetCaster()->ToPlayer(); uint32 factionId = GetSpellInfo()->Effects[effIndex].CalcValue(); int32 repChange = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); @@ -1410,18 +1400,16 @@ public: // EFFECT_INDEX_2 most likely update at war state, we already handle this in SetReputation } - } + void Register() + { + OnEffectHit += SpellEffectFn(spell_gen_oracle_wolvar_reputation_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; - void Register() + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_gen_oracle_wolvar_reputation_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_gen_oracle_wolvar_reputation_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_gen_oracle_wolvar_reputation_SpellScript(); - } }; enum DamageReductionAura @@ -1435,53 +1423,48 @@ enum DamageReductionAura class spell_gen_damage_reduction_aura : public SpellScriptLoader { -public: - spell_gen_damage_reduction_aura() : SpellScriptLoader("spell_gen_damage_reduction_aura") { } + public: + spell_gen_damage_reduction_aura() : SpellScriptLoader("spell_gen_damage_reduction_aura") { } - class spell_gen_damage_reduction_AuraScript : public AuraScript - { - PrepareAuraScript(spell_gen_damage_reduction_AuraScript); - - bool Validate(SpellInfo const* /*SpellEntry*/) + class spell_gen_damage_reduction_AuraScript : public AuraScript { - if (!sSpellMgr->GetSpellInfo(SPELL_DAMAGE_REDUCTION_AURA)) - return false; - return true; - } + PrepareAuraScript(spell_gen_damage_reduction_AuraScript); - void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DAMAGE_REDUCTION_AURA)) + return false; + return true; + } + + void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); + target->CastSpell(target, SPELL_DAMAGE_REDUCTION_AURA, true); + } + + void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); + if (target->HasAura(SPELL_DAMAGE_REDUCTION_AURA) && !(target->HasAura(SPELL_BLESSING_OF_SANCTUARY) || + target->HasAura(SPELL_GREATER_BLESSING_OF_SANCTUARY) || + target->HasAura(SPELL_RENEWED_HOPE) || + target->HasAura(SPELL_VIGILANCE))) + target->RemoveAurasDueToSpell(SPELL_DAMAGE_REDUCTION_AURA); + } + + void Register() + { + OnEffectApply += AuraEffectApplyFn(spell_gen_damage_reduction_AuraScript::OnApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + OnEffectRemove += AuraEffectRemoveFn(spell_gen_damage_reduction_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + } + + }; + + AuraScript* GetAuraScript() const { - Unit* target = GetTarget(); - target->CastSpell(target, SPELL_DAMAGE_REDUCTION_AURA, true); + return new spell_gen_damage_reduction_AuraScript(); } - - void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - Unit* target = GetTarget(); - if (!target->HasAura(SPELL_DAMAGE_REDUCTION_AURA)) - return; - - if (target->HasAura(SPELL_BLESSING_OF_SANCTUARY) || - target->HasAura(SPELL_GREATER_BLESSING_OF_SANCTUARY) || - target->HasAura(SPELL_RENEWED_HOPE) || - target->HasAura(SPELL_VIGILANCE)) - return; - - target->RemoveAurasDueToSpell(SPELL_DAMAGE_REDUCTION_AURA); - } - - void Register() - { - OnEffectApply += AuraEffectApplyFn(spell_gen_damage_reduction_AuraScript::OnApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); - OnEffectRemove += AuraEffectRemoveFn(spell_gen_damage_reduction_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); - } - - }; - - AuraScript* GetAuraScript() const - { - return new spell_gen_damage_reduction_AuraScript(); - } }; class spell_gen_luck_of_the_draw : public SpellScriptLoader @@ -1493,6 +1476,11 @@ class spell_gen_luck_of_the_draw : public SpellScriptLoader { PrepareAuraScript(spell_gen_luck_of_the_draw_AuraScript); + bool Load() + { + return GetUnitOwner()->GetTypeId() == TYPEID_PLAYER; + } + // cheap hax to make it have update calls void CalcPeriodic(AuraEffect const* /*effect*/, bool& isPeriodic, int32& amplitude) { @@ -1502,30 +1490,30 @@ class spell_gen_luck_of_the_draw : public SpellScriptLoader void Update(AuraEffect* /*effect*/) { - if (GetUnitOwner()->GetTypeId() != TYPEID_PLAYER) - return; - - const LfgDungeonSet dungeons = sLFGMgr->GetSelectedDungeons(GetUnitOwner()->GetGUID()); - LfgDungeonSet::const_iterator itr = dungeons.begin(); - - if (itr == dungeons.end()) + if (Player* owner = GetUnitOwner()->ToPlayer()) { + const LfgDungeonSet dungeons = sLFGMgr->GetSelectedDungeons(owner->GetGUID()); + LfgDungeonSet::const_iterator itr = dungeons.begin(); + + if (itr == dungeons.end()) + { + Remove(AURA_REMOVE_BY_DEFAULT); + return; + } + + + LFGDungeonEntry const* randomDungeon = sLFGDungeonStore.LookupEntry(*itr); + if (Group* group = owner->GetGroup()) + if (Map const* map = owner->GetMap()) + if (group->isLFGGroup()) + if (uint32 dungeonId = sLFGMgr->GetDungeon(group->GetGUID(), true)) + if (LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(dungeonId)) + if (uint32(dungeon->map) == map->GetId() && dungeon->difficulty == map->GetDifficulty()) + if (randomDungeon && randomDungeon->type == LFG_TYPE_RANDOM) + return; // in correct dungeon + Remove(AURA_REMOVE_BY_DEFAULT); - return; } - - - LFGDungeonEntry const* randomDungeon = sLFGDungeonStore.LookupEntry(*itr); - Group* group = GetUnitOwner()->ToPlayer()->GetGroup(); - Map const* map = GetUnitOwner()->GetMap(); - if (group && group->isLFGGroup()) - if (uint32 dungeonId = sLFGMgr->GetDungeon(group->GetGUID(), true)) - if (LFGDungeonEntry const* dungeon = sLFGDungeonStore.LookupEntry(dungeonId)) - if (dungeon->map == map->GetId() && dungeon->difficulty == map->GetDifficulty()) - if (randomDungeon && randomDungeon->type == LFG_TYPE_RANDOM) - return; // in correct dungeon - - Remove(AURA_REMOVE_BY_DEFAULT); } void Register() @@ -1541,6 +1529,178 @@ class spell_gen_luck_of_the_draw : public SpellScriptLoader } }; +enum DummyTrigger +{ + SPELL_PERSISTANT_SHIELD_TRIGGERED = 26470, + SPELL_PERSISTANT_SHIELD = 26467, +}; + +class spell_gen_dummy_trigger : public SpellScriptLoader +{ + public: + spell_gen_dummy_trigger() : SpellScriptLoader("spell_gen_dummy_trigger") { } + + class spell_gen_dummy_trigger_SpellScript : public SpellScript + { + PrepareSpellScript(spell_gen_dummy_trigger_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_PERSISTANT_SHIELD_TRIGGERED) || !sSpellMgr->GetSpellInfo(SPELL_PERSISTANT_SHIELD)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + if (SpellInfo const* triggeredByAuraSpell = GetTriggeringSpell()) + if (triggeredByAuraSpell->Id == SPELL_PERSISTANT_SHIELD_TRIGGERED) + caster->CastCustomSpell(target, SPELL_PERSISTANT_SHIELD_TRIGGERED, &damage, NULL, NULL, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_gen_dummy_trigger_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_gen_dummy_trigger_SpellScript(); + } + +}; + +class spell_gen_spirit_healer_res : public SpellScriptLoader +{ + public: + spell_gen_spirit_healer_res(): SpellScriptLoader("spell_gen_spirit_healer_res") { } + + class spell_gen_spirit_healer_res_SpellScript : public SpellScript + { + PrepareSpellScript(spell_gen_spirit_healer_res_SpellScript); + + bool Load() + { + return GetOriginalCaster()->GetTypeId() == TYPEID_PLAYER; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (Player* originalCaster = GetOriginalCaster()->ToPlayer()) + { + if (Unit* target = GetHitUnit()) + { + WorldPacket data(SMSG_SPIRIT_HEALER_CONFIRM, 8); + data << uint64(target->GetGUID()); + originalCaster->GetSession()->SendPacket(&data); + } + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_gen_spirit_healer_res_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_gen_spirit_healer_res_SpellScript(); + } +}; + +enum TransporterBackfires +{ + SPELL_TRANSPORTER_MALFUNCTION_POLYMORPH = 23444, + SPELL_TRANSPORTER_EVIL_TWIN = 23445, + SPELL_TRANSPORTER_MALFUNCTION_MISS = 36902, +}; + +class spell_gen_gadgetzan_transporter_backfire : public SpellScriptLoader +{ + public: + spell_gen_gadgetzan_transporter_backfire() : SpellScriptLoader("spell_gen_gadgetzan_transporter_backfire") { } + + class spell_gen_gadgetzan_transporter_backfire_SpellScript : public SpellScript + { + PrepareSpellScript(spell_gen_gadgetzan_transporter_backfire_SpellScript) + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_TRANSPORTER_MALFUNCTION_POLYMORPH) || !sSpellMgr->GetSpellInfo(SPELL_TRANSPORTER_EVIL_TWIN) + || !sSpellMgr->GetSpellInfo(SPELL_TRANSPORTER_MALFUNCTION_MISS)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + int32 r = irand(0, 119); + if (r < 20) // Transporter Malfunction - 1/6 polymorph + caster->CastSpell(caster, SPELL_TRANSPORTER_MALFUNCTION_POLYMORPH, true); + else if (r < 100) // Evil Twin - 4/6 evil twin + caster->CastSpell(caster, SPELL_TRANSPORTER_EVIL_TWIN, true); + else // Transporter Malfunction - 1/6 miss the target + caster->CastSpell(caster, SPELL_TRANSPORTER_MALFUNCTION_MISS, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_gen_gadgetzan_transporter_backfire_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_gen_gadgetzan_transporter_backfire_SpellScript(); + } +}; + +enum GnomishTransporter +{ + SPELL_TRANSPORTER_SUCCESS = 23441, + SPELL_TRANSPORTER_FAILURE = 23446, +}; + +class spell_gen_gnomish_transporter : public SpellScriptLoader +{ + public: + spell_gen_gnomish_transporter() : SpellScriptLoader("spell_gen_gnomish_transporter") { } + + class spell_gen_gnomish_transporter_SpellScript : public SpellScript + { + PrepareSpellScript(spell_gen_gnomish_transporter_SpellScript) + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_TRANSPORTER_SUCCESS) || !sSpellMgr->GetSpellInfo(SPELL_TRANSPORTER_FAILURE)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + caster->CastSpell(caster, roll_chance_i(50) ? SPELL_TRANSPORTER_SUCCESS : SPELL_TRANSPORTER_FAILURE , true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_gen_gnomish_transporter_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_gen_gnomish_transporter_SpellScript(); + } +}; + enum DalaranDisguiseSpells { SPELL_SUNREAVER_DISGUISE_TRIGGER = 69672, @@ -1565,15 +1725,11 @@ class spell_gen_dalaran_disguise : public SpellScriptLoader switch (spellEntry->Id) { case SPELL_SUNREAVER_DISGUISE_TRIGGER: - if (!sSpellMgr->GetSpellInfo(SPELL_SUNREAVER_DISGUISE_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUNREAVER_DISGUISE_MALE)) + if (!sSpellMgr->GetSpellInfo(SPELL_SUNREAVER_DISGUISE_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_SUNREAVER_DISGUISE_MALE)) return false; break; case SPELL_SILVER_COVENANT_DISGUISE_TRIGGER: - if (!sSpellMgr->GetSpellInfo(SPELL_SILVER_COVENANT_DISGUISE_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SILVER_COVENANT_DISGUISE_MALE)) + if (!sSpellMgr->GetSpellInfo(SPELL_SILVER_COVENANT_DISGUISE_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_SILVER_COVENANT_DISGUISE_MALE)) return false; break; } @@ -1599,7 +1755,6 @@ class spell_gen_dalaran_disguise : public SpellScriptLoader default: break; } - GetCaster()->CastSpell(player, spellId, true); } } @@ -1706,6 +1861,8 @@ class spell_gen_break_shield: public SpellScriptLoader } break; } + default: + break; } } @@ -1794,6 +1951,7 @@ class spell_gen_mounted_charge: public SpellScriptLoader { case SPELL_CHARGE_TRIGGER_TRIAL_CHAMPION: spellId = SPELL_CHARGE_CHARGING_EFFECT_20K_1; + break; case SPELL_CHARGE_TRIGGER_FACTION_MOUNTS: spellId = SPELL_CHARGE_CHARGING_EFFECT_8K5; break; @@ -1834,7 +1992,7 @@ class spell_gen_mounted_charge: public SpellScriptLoader } } - void HandleChargeEffect(SpellEffIndex effIndex) + void HandleChargeEffect(SpellEffIndex /*effIndex*/) { uint32 spellId; @@ -1908,7 +2066,7 @@ class spell_gen_defend : public SpellScriptLoader void RefreshVisualShields(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/) { - if (Unit* caster = GetCaster()) + if (GetCaster()) { Unit* target = GetTarget(); @@ -1989,7 +2147,7 @@ class spell_gen_tournament_duel : public SpellScriptLoader return true; } - void HandleScriptEffect(SpellEffIndex effIndex) + void HandleScriptEffect(SpellEffIndex /*effIndex*/) { if (Unit* rider = GetCaster()->GetCharmer()) { @@ -2351,6 +2509,47 @@ class spell_gen_tournament_pennant : public SpellScriptLoader } }; +enum ChaosBlast +{ + SPELL_CHAOS_BLAST = 37675, +}; + +class spell_gen_chaos_blast : public SpellScriptLoader +{ + public: + spell_gen_chaos_blast() : SpellScriptLoader("spell_gen_chaos_blast") { } + + class spell_gen_chaos_blast_SpellScript : public SpellScript + { + PrepareSpellScript(spell_gen_chaos_blast_SpellScript) + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_CHAOS_BLAST)) + return false; + return true; + } + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 basepoints0 = 100; + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + caster->CastCustomSpell(target, SPELL_CHAOS_BLAST, &basepoints0, NULL, NULL, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_gen_chaos_blast_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_gen_chaos_blast_SpellScript(); + } + +}; + void AddSC_generic_spell_scripts() { new spell_gen_absorb0_hitlimit1(); @@ -2384,6 +2583,10 @@ void AddSC_generic_spell_scripts() new spell_gen_oracle_wolvar_reputation(); new spell_gen_damage_reduction_aura(); new spell_gen_luck_of_the_draw(); + new spell_gen_dummy_trigger(); + new spell_gen_spirit_healer_res(); + new spell_gen_gadgetzan_transporter_backfire(); + new spell_gen_gnomish_transporter(); new spell_gen_dalaran_disguise("spell_gen_sunreaver_disguise"); new spell_gen_dalaran_disguise("spell_gen_silver_covenant_disguise"); new spell_gen_elune_candle(); @@ -2395,4 +2598,5 @@ void AddSC_generic_spell_scripts() new spell_gen_summon_tournament_mount(); new spell_gen_on_tournament_mount(); new spell_gen_tournament_pennant(); + new spell_gen_chaos_blast(); } diff --git a/src/server/scripts/Spells/spell_hunter.cpp b/src/server/scripts/Spells/spell_hunter.cpp index 8a3424ab1..dd9bfd90a 100644 --- a/src/server/scripts/Spells/spell_hunter.cpp +++ b/src/server/scripts/Spells/spell_hunter.cpp @@ -21,9 +21,13 @@ * Scriptnames of files in this file should be prefixed with "spell_hun_". */ -#include "ScriptPCH.h" -#include "SpellAuraEffects.h" +#include "ScriptMgr.h" +#include "Cell.h" +#include "CellImpl.h" #include "GridNotifiers.h" +#include "GridNotifiersImpl.h" +#include "SpellScript.h" +#include "SpellAuraEffects.h" enum HunterSpells { @@ -45,219 +49,215 @@ enum HunterSpells // 13161 Aspect of the Beast class spell_hun_aspect_of_the_beast : public SpellScriptLoader { -public: - spell_hun_aspect_of_the_beast() : SpellScriptLoader("spell_hun_aspect_of_the_beast") { } + public: + spell_hun_aspect_of_the_beast() : SpellScriptLoader("spell_hun_aspect_of_the_beast") { } - class spell_hun_aspect_of_the_beast_AuraScript : public AuraScript - { - PrepareAuraScript(spell_hun_aspect_of_the_beast_AuraScript) - bool Validate(SpellInfo const* /*entry*/) + class spell_hun_aspect_of_the_beast_AuraScript : public AuraScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET)) - return false; - return true; - } + PrepareAuraScript(spell_hun_aspect_of_the_beast_AuraScript); - void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*entry*/) + { + if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET)) + return false; + return true; + } + + void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + if (Player* caster = GetCaster()->ToPlayer()) + if (Pet* pet = caster->GetPet()) + pet->RemoveAurasDueToSpell(HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET); + } + + void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + if (Player* caster = GetCaster()->ToPlayer()) + if (caster->GetPet()) + caster->CastSpell(caster, HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET, true); + } + + void Register() + { + AfterEffectApply += AuraEffectApplyFn(spell_hun_aspect_of_the_beast_AuraScript::OnApply, EFFECT_0, SPELL_AURA_UNTRACKABLE, AURA_EFFECT_HANDLE_REAL); + AfterEffectRemove += AuraEffectRemoveFn(spell_hun_aspect_of_the_beast_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_UNTRACKABLE, AURA_EFFECT_HANDLE_REAL); + } + }; + + AuraScript* GetAuraScript() const { - if (!GetCaster()) - return; - - Unit* caster = GetCaster(); - if (caster->ToPlayer()) - if (Pet* pet = caster->ToPlayer()->GetPet()) - pet->RemoveAurasDueToSpell(HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET); + return new spell_hun_aspect_of_the_beast_AuraScript(); } - - void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - if (!GetCaster()) - return; - - Unit* caster = GetCaster(); - if (caster->ToPlayer()) - if (caster->ToPlayer()->GetPet()) - caster->CastSpell(caster, HUNTER_SPELL_ASPECT_OF_THE_BEAST_PET, true); - } - - void Register() - { - AfterEffectApply += AuraEffectApplyFn(spell_hun_aspect_of_the_beast_AuraScript::OnApply, EFFECT_0, SPELL_AURA_UNTRACKABLE, AURA_EFFECT_HANDLE_REAL); - AfterEffectRemove += AuraEffectRemoveFn(spell_hun_aspect_of_the_beast_AuraScript::OnRemove, EFFECT_0, SPELL_AURA_UNTRACKABLE, AURA_EFFECT_HANDLE_REAL); - } - }; - - AuraScript* GetAuraScript() const - { - return new spell_hun_aspect_of_the_beast_AuraScript(); - } }; // 53209 Chimera Shot class spell_hun_chimera_shot : public SpellScriptLoader { -public: - spell_hun_chimera_shot() : SpellScriptLoader("spell_hun_chimera_shot") { } + public: + spell_hun_chimera_shot() : SpellScriptLoader("spell_hun_chimera_shot") { } - class spell_hun_chimera_shot_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_chimera_shot_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_hun_chimera_shot_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_SERPENT)) - return false; - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_VIPER)) - return false; - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_SCORPID)) - return false; - return true; - } + PrepareSpellScript(spell_hun_chimera_shot_SpellScript); - void HandleScriptEffect(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - Unit* unitTarget = GetHitUnit(); - if (!unitTarget) - return; - - uint32 spellId = 0; - int32 basePoint = 0; - Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras(); - for (Unit::AuraApplicationMap::iterator i = Auras.begin(); i != Auras.end(); ++i) + bool Validate(SpellInfo const* /*spellEntry*/) { - Aura* aura = i->second->GetBase(); - if (aura->GetCasterGUID() != caster->GetGUID()) - continue; - - // Search only Serpent Sting, Viper Sting, Scorpid Sting auras - flag96 familyFlag = aura->GetSpellInfo()->SpellFamilyFlags; - if (!(familyFlag[1] & 0x00000080 || familyFlag[0] & 0x0000C000)) - continue; - if (AuraEffect const* aurEff = aura->GetEffect(0)) - { - // Serpent Sting - Instantly deals 40% of the damage done by your Serpent Sting. - if (familyFlag[0] & 0x4000) - { - int32 TickCount = aurEff->GetTotalTicks(); - spellId = HUNTER_SPELL_CHIMERA_SHOT_SERPENT; - basePoint = caster->SpellDamageBonus(unitTarget, aura->GetSpellInfo(), aurEff->GetAmount(), DOT, aura->GetStackAmount()); - ApplyPctN(basePoint, TickCount * 40); - } - // Viper Sting - Instantly restores mana to you equal to 60% of the total amount drained by your Viper Sting. - else if (familyFlag[1] & 0x00000080) - { - int32 TickCount = aura->GetEffect(0)->GetTotalTicks(); - spellId = HUNTER_SPELL_CHIMERA_SHOT_VIPER; - - // Amount of one aura tick - basePoint = int32(CalculatePctN(unitTarget->GetMaxPower(POWER_MANA), aurEff->GetAmount())); - int32 casterBasePoint = aurEff->GetAmount() * unitTarget->GetMaxPower(POWER_MANA) / 50; // TODO: WTF? caster uses unitTarget? - if (basePoint > casterBasePoint) - basePoint = casterBasePoint; - ApplyPctN(basePoint, TickCount * 60); - } - // Scorpid Sting - Attempts to Disarm the target for 10 sec. This effect cannot occur more than once per 1 minute. - else if (familyFlag[0] & 0x00008000) - spellId = HUNTER_SPELL_CHIMERA_SHOT_SCORPID; - // ?? nothing say in spell desc (possibly need addition check) - //if (familyFlag & 0x0000010000000000LL || // dot - // familyFlag & 0x0000100000000000LL) // stun - //{ - // spellId = 53366; // 53366 Chimera Shot - Wyvern - //} - - // Refresh aura duration - aura->RefreshDuration(); - } - break; + if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_SERPENT) || !sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_VIPER) || !sSpellMgr->GetSpellInfo(HUNTER_SPELL_CHIMERA_SHOT_SCORPID)) + return false; + return true; } - if (spellId) - caster->CastCustomSpell(unitTarget, spellId, &basePoint, 0, 0, true); - if (spellId == HUNTER_SPELL_CHIMERA_SHOT_SCORPID && caster->ToPlayer()) // Scorpid Sting - Add 1 minute cooldown - caster->ToPlayer()->AddSpellCooldown(spellId, 0, uint32(time(NULL) + 60)); - } - void Register() + void HandleScriptEffect(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* unitTarget = GetHitUnit()) + { + uint32 spellId = 0; + int32 basePoint = 0; + Unit::AuraApplicationMap& Auras = unitTarget->GetAppliedAuras(); + for (Unit::AuraApplicationMap::iterator i = Auras.begin(); i != Auras.end(); ++i) + { + Aura* aura = i->second->GetBase(); + if (aura->GetCasterGUID() != caster->GetGUID()) + continue; + + // Search only Serpent Sting, Viper Sting, Scorpid Sting auras + flag96 familyFlag = aura->GetSpellInfo()->SpellFamilyFlags; + if (!(familyFlag[1] & 0x00000080 || familyFlag[0] & 0x0000C000)) + continue; + if (AuraEffect const* aurEff = aura->GetEffect(0)) + { + // Serpent Sting - Instantly deals 40% of the damage done by your Serpent Sting. + if (familyFlag[0] & 0x4000) + { + int32 TickCount = aurEff->GetTotalTicks(); + spellId = HUNTER_SPELL_CHIMERA_SHOT_SERPENT; + basePoint = caster->SpellDamageBonus(unitTarget, aura->GetSpellInfo(), aurEff->GetAmount(), DOT, aura->GetStackAmount()); + ApplyPctN(basePoint, TickCount * 40); + } + // Viper Sting - Instantly restores mana to you equal to 60% of the total amount drained by your Viper Sting. + else if (familyFlag[1] & 0x00000080) + { + int32 TickCount = aura->GetEffect(0)->GetTotalTicks(); + spellId = HUNTER_SPELL_CHIMERA_SHOT_VIPER; + + // Amount of one aura tick + basePoint = int32(CalculatePctN(unitTarget->GetMaxPower(POWER_MANA), aurEff->GetAmount())); + int32 casterBasePoint = aurEff->GetAmount() * unitTarget->GetMaxPower(POWER_MANA) / 50; // TODO: WTF? caster uses unitTarget? + if (basePoint > casterBasePoint) + basePoint = casterBasePoint; + ApplyPctN(basePoint, TickCount * 60); + } + // Scorpid Sting - Attempts to Disarm the target for 10 sec. This effect cannot occur more than once per 1 minute. + else if (familyFlag[0] & 0x00008000) + spellId = HUNTER_SPELL_CHIMERA_SHOT_SCORPID; + // ?? nothing say in spell desc (possibly need addition check) + //if (familyFlag & 0x0000010000000000LL || // dot + // familyFlag & 0x0000100000000000LL) // stun + //{ + // spellId = 53366; // 53366 Chimera Shot - Wyvern + //} + + // Refresh aura duration + aura->RefreshDuration(); + } + break; + } + if (spellId) + caster->CastCustomSpell(unitTarget, spellId, &basePoint, 0, 0, true); + if (spellId == HUNTER_SPELL_CHIMERA_SHOT_SCORPID && caster->ToPlayer()) // Scorpid Sting - Add 1 minute cooldown + caster->ToPlayer()->AddSpellCooldown(spellId, 0, uint32(time(NULL) + 60)); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_hun_chimera_shot_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_hun_chimera_shot_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + return new spell_hun_chimera_shot_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_chimera_shot_SpellScript(); - } }; // 53412 Invigoration class spell_hun_invigoration : public SpellScriptLoader { -public: - spell_hun_invigoration() : SpellScriptLoader("spell_hun_invigoration") { } + public: + spell_hun_invigoration() : SpellScriptLoader("spell_hun_invigoration") { } - class spell_hun_invigoration_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_invigoration_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_hun_invigoration_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_INVIGORATION_TRIGGERED)) - return false; - return true; - } + PrepareSpellScript(spell_hun_invigoration_SpellScript); - void HandleScriptEffect(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_INVIGORATION_TRIGGERED)) + return false; + return true; + } + + void HandleScriptEffect(SpellEffIndex /*effIndex*/) + { + if (Unit* unitTarget = GetHitUnit()) + if (AuraEffect* aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_HUNTER, 3487, 0)) + if (roll_chance_i(aurEff->GetAmount())) + unitTarget->CastSpell(unitTarget, HUNTER_SPELL_INVIGORATION_TRIGGERED, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_hun_invigoration_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } + }; + + SpellScript* GetSpellScript() const { - if (Unit* unitTarget = GetHitUnit()) - if (AuraEffect* aurEff = unitTarget->GetDummyAuraEffect(SPELLFAMILY_HUNTER, 3487, 0)) - if (roll_chance_i(aurEff->GetAmount())) - unitTarget->CastSpell(unitTarget, HUNTER_SPELL_INVIGORATION_TRIGGERED, true); + return new spell_hun_invigoration_SpellScript(); } - - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_hun_invigoration_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_invigoration_SpellScript(); - } }; class spell_hun_last_stand_pet : public SpellScriptLoader { -public: - spell_hun_last_stand_pet() : SpellScriptLoader("spell_hun_last_stand_pet") { } + public: + spell_hun_last_stand_pet() : SpellScriptLoader("spell_hun_last_stand_pet") { } - class spell_hun_last_stand_pet_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_last_stand_pet_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_hun_last_stand_pet_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_PET_SPELL_LAST_STAND_TRIGGERED)) - return false; - return true; - } + PrepareSpellScript(spell_hun_last_stand_pet_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(HUNTER_PET_SPELL_LAST_STAND_TRIGGERED)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + int32 healthModSpellBasePoints0 = int32(caster->CountPctFromMaxHealth(30)); + caster->CastCustomSpell(caster, HUNTER_PET_SPELL_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, NULL, NULL, true, NULL); + } + + void Register() + { + // add dummy effect spell handler to pet's Last Stand + OnEffectHitTarget += SpellEffectFn(spell_hun_last_stand_pet_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - Unit* caster = GetCaster(); - int32 healthModSpellBasePoints0 = int32(caster->CountPctFromMaxHealth(30)); - caster->CastCustomSpell(caster, HUNTER_PET_SPELL_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, NULL, NULL, true, NULL); + return new spell_hun_last_stand_pet_SpellScript(); } - - void Register() - { - // add dummy effect spell handler to pet's Last Stand - OnEffectHitTarget += SpellEffectFn(spell_hun_last_stand_pet_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_last_stand_pet_SpellScript(); - } }; class spell_hun_masters_call : public SpellScriptLoader @@ -267,14 +267,11 @@ class spell_hun_masters_call : public SpellScriptLoader class spell_hun_masters_call_SpellScript : public SpellScript { - PrepareSpellScript(spell_hun_masters_call_SpellScript) + PrepareSpellScript(spell_hun_masters_call_SpellScript); + bool Validate(SpellInfo const* spellEntry) { - if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_MASTERS_CALL_TRIGGERED)) - return false; - if (!sSpellMgr->GetSpellInfo(spellEntry->Effects[EFFECT_0].CalcValue())) - return false; - if (!sSpellMgr->GetSpellInfo(spellEntry->Effects[EFFECT_1].CalcValue())) + if (!sSpellMgr->GetSpellInfo(HUNTER_SPELL_MASTERS_CALL_TRIGGERED) || !sSpellMgr->GetSpellInfo(spellEntry->Effects[EFFECT_0].CalcValue()) || !sSpellMgr->GetSpellInfo(spellEntry->Effects[EFFECT_1].CalcValue())) return false; return true; } @@ -312,80 +309,86 @@ class spell_hun_masters_call : public SpellScriptLoader class spell_hun_readiness : public SpellScriptLoader { -public: - spell_hun_readiness() : SpellScriptLoader("spell_hun_readiness") { } + public: + spell_hun_readiness() : SpellScriptLoader("spell_hun_readiness") { } - class spell_hun_readiness_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_readiness_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_hun_readiness_SpellScript : public SpellScript { - Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_hun_readiness_SpellScript); - // immediately finishes the cooldown on your other Hunter abilities except Bestial Wrath - const SpellCooldowns& cm = caster->ToPlayer()->GetSpellCooldownMap(); - for (SpellCooldowns::const_iterator itr = cm.begin(); itr != cm.end();) + bool Load() { - SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first); - - ///! If spellId in cooldown map isn't valid, the above will return a null pointer. - if (spellInfo && - spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && - spellInfo->Id != HUNTER_SPELL_READINESS && - spellInfo->Id != HUNTER_SPELL_BESTIAL_WRATH && - spellInfo->GetRecoveryTime() > 0) - caster->ToPlayer()->RemoveSpellCooldown((itr++)->first, true); - else - ++itr; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + // immediately finishes the cooldown on your other Hunter abilities except Bestial Wrath + const SpellCooldowns& cm = caster->ToPlayer()->GetSpellCooldownMap(); + for (SpellCooldowns::const_iterator itr = cm.begin(); itr != cm.end();) + { + SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first); + + ///! If spellId in cooldown map isn't valid, the above will return a null pointer. + if (spellInfo && + spellInfo->SpellFamilyName == SPELLFAMILY_HUNTER && + spellInfo->Id != HUNTER_SPELL_READINESS && + spellInfo->Id != HUNTER_SPELL_BESTIAL_WRATH && + spellInfo->GetRecoveryTime() > 0) + caster->RemoveSpellCooldown((itr++)->first, true); + else + ++itr; + } + } + + void Register() + { + // add dummy effect spell handler to Readiness + OnEffectHitTarget += SpellEffectFn(spell_hun_readiness_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - // add dummy effect spell handler to Readiness - OnEffectHitTarget += SpellEffectFn(spell_hun_readiness_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_hun_readiness_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_readiness_SpellScript(); - } }; // 37506 Scatter Shot class spell_hun_scatter_shot : public SpellScriptLoader { -public: - spell_hun_scatter_shot() : SpellScriptLoader("spell_hun_scatter_shot") { } + public: + spell_hun_scatter_shot() : SpellScriptLoader("spell_hun_scatter_shot") { } - class spell_hun_scatter_shot_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_scatter_shot_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_hun_scatter_shot_SpellScript : public SpellScript { - Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_hun_scatter_shot_SpellScript); - // break Auto Shot and autohit - caster->InterruptSpell(CURRENT_AUTOREPEAT_SPELL); - caster->AttackStop(); - caster->ToPlayer()->SendAttackSwingCancelAttack(); - } + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + // break Auto Shot and autohit + caster->InterruptSpell(CURRENT_AUTOREPEAT_SPELL); + caster->AttackStop(); + caster->SendAttackSwingCancelAttack(); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_hun_scatter_shot_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_hun_scatter_shot_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_hun_scatter_shot_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_scatter_shot_SpellScript(); - } }; // 53302, 53303, 53304 Sniper Training @@ -397,169 +400,164 @@ enum eSniperTrainingSpells class spell_hun_sniper_training : public SpellScriptLoader { -public: - spell_hun_sniper_training() : SpellScriptLoader("spell_hun_sniper_training") { } + public: + spell_hun_sniper_training() : SpellScriptLoader("spell_hun_sniper_training") { } - class spell_hun_sniper_training_AuraScript : public AuraScript - { - PrepareAuraScript(spell_hun_sniper_training_AuraScript) - bool Validate(SpellInfo const* /*entry*/) + class spell_hun_sniper_training_AuraScript : public AuraScript { - if (!sSpellMgr->GetSpellInfo(SPELL_SNIPER_TRAINING_R1)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SNIPER_TRAINING_BUFF_R1)) - return false; - return true; - } + PrepareAuraScript(spell_hun_sniper_training_AuraScript); - void HandlePeriodic(AuraEffect const* aurEff) - { - PreventDefaultAction(); - if (aurEff->GetAmount() > 0) - return; - - Unit* caster = GetCaster(); - - if (!caster) - return; - - uint32 spellId = SPELL_SNIPER_TRAINING_BUFF_R1 + GetId() - SPELL_SNIPER_TRAINING_R1; - Unit* target = GetTarget(); - if (!target->HasAura(spellId)) + bool Validate(SpellInfo const* /*entry*/) { - SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(spellId); - Unit* triggerCaster = triggeredSpellInfo->NeedsToBeTriggeredByCaster() ? caster : target; - triggerCaster->CastSpell(target, triggeredSpellInfo, true, 0, aurEff); + if (!sSpellMgr->GetSpellInfo(SPELL_SNIPER_TRAINING_R1) || !sSpellMgr->GetSpellInfo(SPELL_SNIPER_TRAINING_BUFF_R1)) + return false; + return true; } - } - void HandleUpdatePeriodic(AuraEffect* aurEff) - { - Unit* target = GetUnitOwner(); - if (Player* playerTarget = target->ToPlayer()) + void HandlePeriodic(AuraEffect const* aurEff) { - int32 baseAmount = aurEff->GetBaseAmount(); - int32 amount = playerTarget->isMoving() ? - target->CalculateSpellDamage(target, GetSpellInfo(), aurEff->GetEffIndex(), &baseAmount) : - aurEff->GetAmount() - 1; - aurEff->SetAmount(amount); + PreventDefaultAction(); + if (aurEff->GetAmount() <= 0) + { + Unit* caster = GetCaster(); + uint32 spellId = SPELL_SNIPER_TRAINING_BUFF_R1 + GetId() - SPELL_SNIPER_TRAINING_R1; + if (Unit* target = GetTarget()) + if (!target->HasAura(spellId)) + { + SpellInfo const* triggeredSpellInfo = sSpellMgr->GetSpellInfo(spellId); + Unit* triggerCaster = triggeredSpellInfo->NeedsToBeTriggeredByCaster() ? caster : target; + triggerCaster->CastSpell(target, triggeredSpellInfo, true, 0, aurEff); + } + } } - } - void Register() + void HandleUpdatePeriodic(AuraEffect* aurEff) + { + if (Player* playerTarget = GetUnitOwner()->ToPlayer()) + { + int32 baseAmount = aurEff->GetBaseAmount(); + int32 amount = playerTarget->isMoving() ? + playerTarget->CalculateSpellDamage(playerTarget, GetSpellInfo(), aurEff->GetEffIndex(), &baseAmount) : + aurEff->GetAmount() - 1; + aurEff->SetAmount(amount); + } + } + + void Register() + { + OnEffectPeriodic += AuraEffectPeriodicFn(spell_hun_sniper_training_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL); + OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_hun_sniper_training_AuraScript::HandleUpdatePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL); + } + }; + + AuraScript* GetAuraScript() const { - OnEffectPeriodic += AuraEffectPeriodicFn(spell_hun_sniper_training_AuraScript::HandlePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL); - OnEffectUpdatePeriodic += AuraEffectUpdatePeriodicFn(spell_hun_sniper_training_AuraScript::HandleUpdatePeriodic, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL); + return new spell_hun_sniper_training_AuraScript(); } - }; - - AuraScript* GetAuraScript() const - { - return new spell_hun_sniper_training_AuraScript(); - } }; class spell_hun_pet_heart_of_the_phoenix : public SpellScriptLoader { -public: - spell_hun_pet_heart_of_the_phoenix() : SpellScriptLoader("spell_hun_pet_heart_of_the_phoenix") { } + public: + spell_hun_pet_heart_of_the_phoenix() : SpellScriptLoader("spell_hun_pet_heart_of_the_phoenix") { } - class spell_hun_pet_heart_of_the_phoenix_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_pet_heart_of_the_phoenix_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_hun_pet_heart_of_the_phoenix_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED)) - return false; - if (!sSpellMgr->GetSpellInfo(HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF)) - return false; - return true; - } + PrepareSpellScript(spell_hun_pet_heart_of_the_phoenix_SpellScript); - void HandleScript(SpellEffIndex /*effIndex*/) + bool Load() + { + if (!GetCaster()->isPet()) + return false; + return true; + } + + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED) || !sSpellMgr->GetSpellInfo(HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF)) + return false; + return true; + } + + void HandleScript(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* owner = caster->GetOwner()) + if (!caster->HasAura(HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF)) + { + owner->CastCustomSpell(HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED, SPELLVALUE_BASE_POINT0, 100, caster, true); + caster->CastSpell(caster, HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF, true); + } + } + + void Register() + { + // add dummy effect spell handler to pet's Last Stand + OnEffectHitTarget += SpellEffectFn(spell_hun_pet_heart_of_the_phoenix_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } + }; + + SpellScript* GetSpellScript() const { - Unit* caster = GetCaster(); - Unit* owner = caster->GetOwner(); - if (!owner || caster->HasAura(HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF)) - return; - owner->CastCustomSpell(HUNTER_PET_HEART_OF_THE_PHOENIX_TRIGGERED, SPELLVALUE_BASE_POINT0, 100, caster, true); - caster->CastSpell(caster, HUNTER_PET_HEART_OF_THE_PHOENIX_DEBUFF, true); + return new spell_hun_pet_heart_of_the_phoenix_SpellScript(); } - - void Register() - { - // add dummy effect spell handler to pet's Last Stand - OnEffectHitTarget += SpellEffectFn(spell_hun_pet_heart_of_the_phoenix_SpellScript::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - - bool Load() - { - if (!GetCaster()->isPet()) - return false; - return true; - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_pet_heart_of_the_phoenix_SpellScript(); - } }; class spell_hun_pet_carrion_feeder : public SpellScriptLoader { -public: - spell_hun_pet_carrion_feeder() : SpellScriptLoader("spell_hun_pet_carrion_feeder") { } + public: + spell_hun_pet_carrion_feeder() : SpellScriptLoader("spell_hun_pet_carrion_feeder") { } - class spell_hun_pet_carrion_feeder_SpellScript : public SpellScript - { - PrepareSpellScript(spell_hun_pet_carrion_feeder_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_hun_pet_carrion_feeder_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(HUNTER_PET_SPELL_CARRION_FEEDER_TRIGGERED)) - return false; - return true; - } + PrepareSpellScript(spell_hun_pet_carrion_feeder_SpellScript); - SpellCastResult CheckIfCorpseNear() + bool Load() + { + if (!GetCaster()->isPet()) + return false; + return true; + } + + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(HUNTER_PET_SPELL_CARRION_FEEDER_TRIGGERED)) + return false; + return true; + } + + SpellCastResult CheckIfCorpseNear() + { + Unit* caster = GetCaster(); + float max_range = GetSpellInfo()->GetMaxRange(false); + WorldObject* result = NULL; + // search for nearby enemy corpse in range + Trinity::AnyDeadUnitSpellTargetInRangeCheck check(caster, max_range, GetSpellInfo(), TARGET_SELECT_CHECK_ENEMY); + Trinity::WorldObjectSearcher searcher(caster, result, check); + caster->GetMap()->VisitFirstFound(caster->m_positionX, caster->m_positionY, max_range, searcher); + if (!result) + return SPELL_FAILED_NO_EDIBLE_CORPSES; + return SPELL_CAST_OK; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + caster->CastSpell(caster, HUNTER_PET_SPELL_CARRION_FEEDER_TRIGGERED, false); + } + + void Register() + { + // add dummy effect spell handler to pet's Last Stand + OnEffectHit += SpellEffectFn(spell_hun_pet_carrion_feeder_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + OnCheckCast += SpellCheckCastFn(spell_hun_pet_carrion_feeder_SpellScript::CheckIfCorpseNear); + } + }; + + SpellScript* GetSpellScript() const { - Unit* caster = GetCaster(); - float max_range = GetSpellInfo()->GetMaxRange(false); - WorldObject* result = NULL; - // search for nearby enemy corpse in range - Trinity::AnyDeadUnitSpellTargetInRangeCheck check(caster, max_range, GetSpellInfo(), TARGET_SELECT_CHECK_ENEMY); - Trinity::WorldObjectSearcher searcher(caster, result, check); - caster->GetMap()->VisitFirstFound(caster->m_positionX, caster->m_positionY, max_range, searcher); - if (!result) - return SPELL_FAILED_NO_EDIBLE_CORPSES; - return SPELL_CAST_OK; + return new spell_hun_pet_carrion_feeder_SpellScript(); } - - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - caster->CastSpell(caster, HUNTER_PET_SPELL_CARRION_FEEDER_TRIGGERED, false); - } - - void Register() - { - // add dummy effect spell handler to pet's Last Stand - OnEffectHit += SpellEffectFn(spell_hun_pet_carrion_feeder_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - OnCheckCast += SpellCheckCastFn(spell_hun_pet_carrion_feeder_SpellScript::CheckIfCorpseNear); - } - - bool Load() - { - if (!GetCaster()->isPet()) - return false; - return true; - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_hun_pet_carrion_feeder_SpellScript(); - } }; void AddSC_hunter_spell_scripts() diff --git a/src/server/scripts/Spells/spell_item.cpp b/src/server/scripts/Spells/spell_item.cpp index b40879d50..7829587b0 100644 --- a/src/server/scripts/Spells/spell_item.cpp +++ b/src/server/scripts/Spells/spell_item.cpp @@ -21,55 +21,59 @@ * Scriptnames of files in this file should be prefixed with "spell_item_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "ScriptedCreature.h" +#include "SpellScript.h" +#include "SpellAuraEffects.h" #include "SkillDiscovery.h" // Generic script for handling item dummy effects which trigger another spell. class spell_item_trigger_spell : public SpellScriptLoader { -private: - uint32 _triggeredSpellId; - -public: - spell_item_trigger_spell(const char* name, uint32 triggeredSpellId) : SpellScriptLoader(name), _triggeredSpellId(triggeredSpellId) { } - - class spell_item_trigger_spell_SpellScript : public SpellScript - { - PrepareSpellScript(spell_item_trigger_spell_SpellScript) private: uint32 _triggeredSpellId; public: - spell_item_trigger_spell_SpellScript(uint32 triggeredSpellId) : SpellScript(), _triggeredSpellId(triggeredSpellId) { } + spell_item_trigger_spell(const char* name, uint32 triggeredSpellId) : SpellScriptLoader(name), _triggeredSpellId(triggeredSpellId) { } - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_item_trigger_spell_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(_triggeredSpellId)) - return false; - return true; - } + PrepareSpellScript(spell_item_trigger_spell_SpellScript); + private: + uint32 _triggeredSpellId; - void HandleDummy(SpellEffIndex /*effIndex*/) + public: + spell_item_trigger_spell_SpellScript(uint32 triggeredSpellId) : SpellScript(), _triggeredSpellId(triggeredSpellId) { } + + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(_triggeredSpellId)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Item* pItem = GetCastItem()) + caster->CastSpell(caster, _triggeredSpellId, true, pItem); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_trigger_spell_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - if (Item* pItem = GetCastItem()) - GetCaster()->CastSpell(GetCaster(), _triggeredSpellId, true, pItem); + return new spell_item_trigger_spell_SpellScript(_triggeredSpellId); } - - void Register() - { - OnEffectHit += SpellEffectFn(spell_item_trigger_spell_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_trigger_spell_SpellScript(_triggeredSpellId); - } }; // http://www.wowhead.com/item=6522 Deviate Fish // 8063 Deviate Fish -enum eDeviateFishSpells +enum DeviateFishSpells { SPELL_SLEEPY = 8064, SPELL_INVIGORATE = 8065, @@ -80,46 +84,48 @@ enum eDeviateFishSpells class spell_item_deviate_fish : public SpellScriptLoader { -public: - spell_item_deviate_fish() : SpellScriptLoader("spell_item_deviate_fish") { } - - class spell_item_deviate_fish_SpellScript : public SpellScript - { - PrepareSpellScript(spell_item_deviate_fish_SpellScript) public: - bool Validate(SpellInfo const* /*spellEntry*/) + spell_item_deviate_fish() : SpellScriptLoader("spell_item_deviate_fish") { } + + class spell_item_deviate_fish_SpellScript : public SpellScript { - for (uint32 spellId = SPELL_SLEEPY; spellId <= SPELL_HEALTHY_SPIRIT; ++spellId) - if (!sSpellMgr->GetSpellInfo(spellId)) - return false; - return true; - } + PrepareSpellScript(spell_item_deviate_fish_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spellEntry*/) + { + for (uint32 spellId = SPELL_SLEEPY; spellId <= SPELL_HEALTHY_SPIRIT; ++spellId) + if (!sSpellMgr->GetSpellInfo(spellId)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = urand(SPELL_SLEEPY, SPELL_HEALTHY_SPIRIT); + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_deviate_fish_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; - - uint32 spellId = urand(SPELL_SLEEPY, SPELL_HEALTHY_SPIRIT); - pCaster->CastSpell(pCaster, spellId, true, NULL); + return new spell_item_deviate_fish_SpellScript(); } - - void Register() - { - OnEffectHit += SpellEffectFn(spell_item_deviate_fish_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_deviate_fish_SpellScript(); - } }; // http://www.wowhead.com/item=47499 Flask of the North // 67019 Flask of the North -enum eFlaskOfTheNorthSpells +enum FlaskOfTheNorthSpells { SPELL_FLASK_OF_THE_NORTH_SP = 67016, SPELL_FLASK_OF_THE_NORTH_AP = 67017, @@ -128,75 +134,68 @@ enum eFlaskOfTheNorthSpells class spell_item_flask_of_the_north : public SpellScriptLoader { -public: - spell_item_flask_of_the_north() : SpellScriptLoader("spell_item_flask_of_the_north") { } - - class spell_item_flask_of_the_north_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_flask_of_the_north_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_SP)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_AP)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_STR)) - return false; - return true; - } + spell_item_flask_of_the_north() : SpellScriptLoader("spell_item_flask_of_the_north") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_flask_of_the_north_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_item_flask_of_the_north_SpellScript); - std::vector possibleSpells; - switch (pCaster->getClass()) + bool Validate(SpellInfo const* /*spellEntry*/) { - case CLASS_WARLOCK: - case CLASS_MAGE: - case CLASS_PRIEST: - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); - break; - case CLASS_DEATH_KNIGHT: - case CLASS_WARRIOR: - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_STR); - break; - case CLASS_ROGUE: - case CLASS_HUNTER: - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_AP); - break; - case CLASS_DRUID: - case CLASS_PALADIN: - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_STR); - break; - case CLASS_SHAMAN: - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); - possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_AP); - break; + if (!sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_SP) || !sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_AP) || !sSpellMgr->GetSpellInfo(SPELL_FLASK_OF_THE_NORTH_STR)) + return false; + return true; } - pCaster->CastSpell(pCaster, possibleSpells[irand(0, (possibleSpells.size() - 1))], true, NULL); - } + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + std::vector possibleSpells; + switch (caster->getClass()) + { + case CLASS_WARLOCK: + case CLASS_MAGE: + case CLASS_PRIEST: + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); + break; + case CLASS_DEATH_KNIGHT: + case CLASS_WARRIOR: + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_STR); + break; + case CLASS_ROGUE: + case CLASS_HUNTER: + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_AP); + break; + case CLASS_DRUID: + case CLASS_PALADIN: + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_STR); + break; + case CLASS_SHAMAN: + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_SP); + possibleSpells.push_back(SPELL_FLASK_OF_THE_NORTH_AP); + break; + } - void Register() + caster->CastSpell(caster, possibleSpells[irand(0, (possibleSpells.size() - 1))], true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_flask_of_the_north_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_flask_of_the_north_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_flask_of_the_north_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_flask_of_the_north_SpellScript(); - } }; // http://www.wowhead.com/item=10645 Gnomish Death Ray // 13280 Gnomish Death Ray -enum eGnomishDeathRay +enum GnomishDeathRay { SPELL_GNOMISH_DEATH_RAY_SELF = 13493, SPELL_GNOMISH_DEATH_RAY_TARGET = 13279, @@ -204,49 +203,45 @@ enum eGnomishDeathRay class spell_item_gnomish_death_ray : public SpellScriptLoader { -public: - spell_item_gnomish_death_ray() : SpellScriptLoader("spell_item_gnomish_death_ray") { } - - class spell_item_gnomish_death_ray_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_gnomish_death_ray_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_GNOMISH_DEATH_RAY_SELF)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_GNOMISH_DEATH_RAY_TARGET)) - return false; - return true; - } + spell_item_gnomish_death_ray() : SpellScriptLoader("spell_item_gnomish_death_ray") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_gnomish_death_ray_SpellScript : public SpellScript { - if (Unit* target = GetHitUnit()) + PrepareSpellScript(spell_item_gnomish_death_ray_SpellScript); + + bool Validate(SpellInfo const* /*spellEntry*/) { - Unit* pCaster = GetCaster(); - if (urand(0, 99) < 15) - pCaster->CastSpell(pCaster, SPELL_GNOMISH_DEATH_RAY_SELF, true, NULL); // failure - else - pCaster->CastSpell(target, SPELL_GNOMISH_DEATH_RAY_TARGET, true, NULL); + if (!sSpellMgr->GetSpellInfo(SPELL_GNOMISH_DEATH_RAY_SELF) || !sSpellMgr->GetSpellInfo(SPELL_GNOMISH_DEATH_RAY_TARGET)) + return false; + return true; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + if (urand(0, 99) < 15) + caster->CastSpell(caster, SPELL_GNOMISH_DEATH_RAY_SELF, true, NULL); // failure + else + caster->CastSpell(target, SPELL_GNOMISH_DEATH_RAY_TARGET, true, NULL); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_gnomish_death_ray_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_item_gnomish_death_ray_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_gnomish_death_ray_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_gnomish_death_ray_SpellScript(); - } }; // http://www.wowhead.com/item=27388 Mr. Pinchy // 33060 Make a Wish -enum eMakeAWish +enum MakeAWish { SPELL_MR_PINCHYS_BLESSING = 33053, SPELL_SUMMON_MIGHTY_MR_PINCHY = 33057, @@ -257,115 +252,110 @@ enum eMakeAWish class spell_item_make_a_wish : public SpellScriptLoader { -public: - spell_item_make_a_wish() : SpellScriptLoader("spell_item_make_a_wish") { } - - class spell_item_make_a_wish_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_make_a_wish_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_MR_PINCHYS_BLESSING)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_MIGHTY_MR_PINCHY)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_FURIOUS_MR_PINCHY)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_TINY_MAGICAL_CRAWDAD)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_MR_PINCHYS_GIFT)) - return false; - return true; - } + spell_item_make_a_wish() : SpellScriptLoader("spell_item_make_a_wish") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_make_a_wish_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_item_make_a_wish_SpellScript); - uint32 spellId = SPELL_MR_PINCHYS_GIFT; - switch (urand(1, 5)) + bool Load() { - case 1: spellId = SPELL_MR_PINCHYS_BLESSING; break; - case 2: spellId = SPELL_SUMMON_MIGHTY_MR_PINCHY; break; - case 3: spellId = SPELL_SUMMON_FURIOUS_MR_PINCHY; break; - case 4: spellId = SPELL_TINY_MAGICAL_CRAWDAD; break; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - pCaster->CastSpell(pCaster, spellId, true, NULL); - } - void Register() + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_MR_PINCHYS_BLESSING) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_MIGHTY_MR_PINCHY) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_FURIOUS_MR_PINCHY) || !sSpellMgr->GetSpellInfo(SPELL_TINY_MAGICAL_CRAWDAD) || !sSpellMgr->GetSpellInfo(SPELL_MR_PINCHYS_GIFT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = SPELL_MR_PINCHYS_GIFT; + switch (urand(1, 5)) + { + case 1: spellId = SPELL_MR_PINCHYS_BLESSING; break; + case 2: spellId = SPELL_SUMMON_MIGHTY_MR_PINCHY; break; + case 3: spellId = SPELL_SUMMON_FURIOUS_MR_PINCHY; break; + case 4: spellId = SPELL_TINY_MAGICAL_CRAWDAD; break; + } + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_make_a_wish_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_make_a_wish_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_make_a_wish_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_make_a_wish_SpellScript(); - } }; // http://www.wowhead.com/item=32686 Mingo's Fortune Giblets // 40802 Mingo's Fortune Generator class spell_item_mingos_fortune_generator : public SpellScriptLoader { -public: - spell_item_mingos_fortune_generator() : SpellScriptLoader("spell_item_mingos_fortune_generator") { } + public: + spell_item_mingos_fortune_generator() : SpellScriptLoader("spell_item_mingos_fortune_generator") { } - class spell_item_mingos_fortune_generator_SpellScript : public SpellScript - { - PrepareSpellScript(spell_item_mingos_fortune_generator_SpellScript) - void HandleDummy(SpellEffIndex effIndex) + class spell_item_mingos_fortune_generator_SpellScript : public SpellScript { - // Selecting one from Bloodstained Fortune item - uint32 newitemid; - switch (urand(1, 20)) + PrepareSpellScript(spell_item_mingos_fortune_generator_SpellScript); + + void HandleDummy(SpellEffIndex effIndex) { - case 1: newitemid = 32688; break; - case 2: newitemid = 32689; break; - case 3: newitemid = 32690; break; - case 4: newitemid = 32691; break; - case 5: newitemid = 32692; break; - case 6: newitemid = 32693; break; - case 7: newitemid = 32700; break; - case 8: newitemid = 32701; break; - case 9: newitemid = 32702; break; - case 10: newitemid = 32703; break; - case 11: newitemid = 32704; break; - case 12: newitemid = 32705; break; - case 13: newitemid = 32706; break; - case 14: newitemid = 32707; break; - case 15: newitemid = 32708; break; - case 16: newitemid = 32709; break; - case 17: newitemid = 32710; break; - case 18: newitemid = 32711; break; - case 19: newitemid = 32712; break; - case 20: newitemid = 32713; break; - default: - return; + // Selecting one from Bloodstained Fortune item + uint32 newitemid; + switch (urand(1, 20)) + { + case 1: newitemid = 32688; break; + case 2: newitemid = 32689; break; + case 3: newitemid = 32690; break; + case 4: newitemid = 32691; break; + case 5: newitemid = 32692; break; + case 6: newitemid = 32693; break; + case 7: newitemid = 32700; break; + case 8: newitemid = 32701; break; + case 9: newitemid = 32702; break; + case 10: newitemid = 32703; break; + case 11: newitemid = 32704; break; + case 12: newitemid = 32705; break; + case 13: newitemid = 32706; break; + case 14: newitemid = 32707; break; + case 15: newitemid = 32708; break; + case 16: newitemid = 32709; break; + case 17: newitemid = 32710; break; + case 18: newitemid = 32711; break; + case 19: newitemid = 32712; break; + case 20: newitemid = 32713; break; + default: + return; + } + + CreateItem(effIndex, newitemid); } - CreateItem(effIndex, newitemid); - } + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_mingos_fortune_generator_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; - void Register() + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_mingos_fortune_generator_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_mingos_fortune_generator_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_mingos_fortune_generator_SpellScript(); - } }; // http://www.wowhead.com/item=10720 Gnomish Net-o-Matic Projector // 13120 Net-o-Matic -enum eNetOMaticSpells +enum NetOMaticSpells { SPELL_NET_O_MATIC_TRIGGERED1 = 16566, SPELL_NET_O_MATIC_TRIGGERED2 = 13119, @@ -374,54 +364,50 @@ enum eNetOMaticSpells class spell_item_net_o_matic : public SpellScriptLoader { -public: - spell_item_net_o_matic() : SpellScriptLoader("spell_item_net_o_matic") { } - - class spell_item_net_o_matic_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_net_o_matic_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED1)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED2)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED3)) - return false; - return true; - } + spell_item_net_o_matic() : SpellScriptLoader("spell_item_net_o_matic") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_net_o_matic_SpellScript : public SpellScript { - if (Unit* target = GetHitUnit()) + PrepareSpellScript(spell_item_net_o_matic_SpellScript); + + bool Validate(SpellInfo const* /*spellEntry*/) { - uint32 spellId = SPELL_NET_O_MATIC_TRIGGERED3; - uint32 roll = urand(0, 99); - if (roll < 2) // 2% for 30 sec self root (off-like chance unknown) - spellId = SPELL_NET_O_MATIC_TRIGGERED1; - else if (roll < 4) // 2% for 20 sec root, charge to target (off-like chance unknown) - spellId = SPELL_NET_O_MATIC_TRIGGERED2; - - GetCaster()->CastSpell(target, spellId, true, NULL); + if (!sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED1) || !sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED2) || !sSpellMgr->GetSpellInfo(SPELL_NET_O_MATIC_TRIGGERED3)) + return false; + return true; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Unit* target = GetHitUnit()) + { + uint32 spellId = SPELL_NET_O_MATIC_TRIGGERED3; + uint32 roll = urand(0, 99); + if (roll < 2) // 2% for 30 sec self root (off-like chance unknown) + spellId = SPELL_NET_O_MATIC_TRIGGERED1; + else if (roll < 4) // 2% for 20 sec root, charge to target (off-like chance unknown) + spellId = SPELL_NET_O_MATIC_TRIGGERED2; + + GetCaster()->CastSpell(target, spellId, true, NULL); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_net_o_matic_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_item_net_o_matic_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_net_o_matic_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_net_o_matic_SpellScript(); - } }; // http://www.wowhead.com/item=8529 Noggenfogger Elixir // 16589 Noggenfogger Elixir -enum eNoggenfoggerElixirSpells +enum NoggenfoggerElixirSpells { SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED1 = 16595, SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED2 = 16593, @@ -430,55 +416,53 @@ enum eNoggenfoggerElixirSpells class spell_item_noggenfogger_elixir : public SpellScriptLoader { -public: - spell_item_noggenfogger_elixir() : SpellScriptLoader("spell_item_noggenfogger_elixir") { } - - class spell_item_noggenfogger_elixir_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_noggenfogger_elixir_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED1)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED2)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED3)) - return false; - return true; - } + spell_item_noggenfogger_elixir() : SpellScriptLoader("spell_item_noggenfogger_elixir") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_noggenfogger_elixir_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_item_noggenfogger_elixir_SpellScript); - uint32 spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED3; - switch (urand(1, 3)) + bool Load() { - case 1: spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED1; break; - case 2: spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED2; break; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - pCaster->CastSpell(pCaster, spellId, true, NULL); - } + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED1) || !sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED2) || !sSpellMgr->GetSpellInfo(SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED3)) + return false; + return true; + } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED3; + switch (urand(1, 3)) + { + case 1: spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED1; break; + case 2: spellId = SPELL_NOGGENFOGGER_ELIXIR_TRIGGERED2; break; + } + + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_noggenfogger_elixir_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_noggenfogger_elixir_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_noggenfogger_elixir_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_noggenfogger_elixir_SpellScript(); - } }; // http://www.wowhead.com/item=6657 Savory Deviate Delight // 8213 Savory Deviate Delight -enum eSavoryDeviateDelight +enum SavoryDeviateDelight { SPELL_FLIP_OUT_MALE = 8219, SPELL_FLIP_OUT_FEMALE = 8220, @@ -488,53 +472,55 @@ enum eSavoryDeviateDelight class spell_item_savory_deviate_delight : public SpellScriptLoader { -public: - spell_item_savory_deviate_delight() : SpellScriptLoader("spell_item_savory_deviate_delight") { } - - class spell_item_savory_deviate_delight_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_savory_deviate_delight_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - for (uint32 spellId = SPELL_FLIP_OUT_MALE; spellId <= SPELL_YAAARRRR_FEMALE; ++spellId) - if (!sSpellMgr->GetSpellInfo(spellId)) - return false; - return true; - } + spell_item_savory_deviate_delight() : SpellScriptLoader("spell_item_savory_deviate_delight") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_savory_deviate_delight_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_item_savory_deviate_delight_SpellScript); - uint32 spellId = 0; - switch (urand(1, 2)) + bool Load() { - // Flip Out - ninja - case 1: spellId = (pCaster->getGender() == GENDER_MALE ? SPELL_FLIP_OUT_MALE : SPELL_FLIP_OUT_FEMALE); break; - // Yaaarrrr - pirate - case 2: spellId = (pCaster->getGender() == GENDER_MALE ? SPELL_YAAARRRR_MALE : SPELL_YAAARRRR_FEMALE); break; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - pCaster->CastSpell(pCaster, spellId, true, NULL); - } - void Register() + bool Validate(SpellInfo const* /*spellEntry*/) + { + for (uint32 spellId = SPELL_FLIP_OUT_MALE; spellId <= SPELL_YAAARRRR_FEMALE; ++spellId) + if (!sSpellMgr->GetSpellInfo(spellId)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = 0; + switch (urand(1, 2)) + { + // Flip Out - ninja + case 1: spellId = (caster->getGender() == GENDER_MALE ? SPELL_FLIP_OUT_MALE : SPELL_FLIP_OUT_FEMALE); break; + // Yaaarrrr - pirate + case 2: spellId = (caster->getGender() == GENDER_MALE ? SPELL_YAAARRRR_MALE : SPELL_YAAARRRR_FEMALE); break; + } + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_savory_deviate_delight_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_savory_deviate_delight_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_savory_deviate_delight_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_savory_deviate_delight_SpellScript(); - } }; // http://www.wowhead.com/item=7734 Six Demon Bag // 14537 Six Demon Bag -enum eSixDemonBagSpells +enum SixDemonBagSpells { SPELL_FROSTBOLT = 11538, SPELL_POLYMORPH = 14621, @@ -546,77 +532,66 @@ enum eSixDemonBagSpells class spell_item_six_demon_bag : public SpellScriptLoader { -public: - spell_item_six_demon_bag() : SpellScriptLoader("spell_item_six_demon_bag") { } - - class spell_item_six_demon_bag_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_six_demon_bag_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_FROSTBOLT)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_POLYMORPH)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_FELHOUND_MINION)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_FIREBALL)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_CHAIN_LIGHTNING)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_ENVELOPING_WINDS)) - return false; - return true; - } + spell_item_six_demon_bag() : SpellScriptLoader("spell_item_six_demon_bag") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_six_demon_bag_SpellScript : public SpellScript { - if (Unit* target = GetHitUnit()) + PrepareSpellScript(spell_item_six_demon_bag_SpellScript); + + bool Validate(SpellInfo const* /*spellEntry*/) { - Unit* pCaster = GetCaster(); - - uint32 spellId = 0; - uint32 rand = urand(0, 99); - if (rand < 25) // Fireball (25% chance) - spellId = SPELL_FIREBALL; - else if (rand < 50) // Frostball (25% chance) - spellId = SPELL_FROSTBOLT; - else if (rand < 70) // Chain Lighting (20% chance) - spellId = SPELL_CHAIN_LIGHTNING; - else if (rand < 80) // Polymorph (10% chance) - { - spellId = SPELL_POLYMORPH; - if (urand(0, 100) <= 30) // 30% chance to self-cast - target = pCaster; - } - else if (rand < 95) // Enveloping Winds (15% chance) - spellId = SPELL_ENVELOPING_WINDS; - else // Summon Felhund minion (5% chance) - { - spellId = SPELL_SUMMON_FELHOUND_MINION; - target = pCaster; - } - - pCaster->CastSpell(target, spellId, true, GetCastItem()); + if (!sSpellMgr->GetSpellInfo(SPELL_FROSTBOLT) || !sSpellMgr->GetSpellInfo(SPELL_POLYMORPH) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_FELHOUND_MINION) || !sSpellMgr->GetSpellInfo(SPELL_FIREBALL) || !sSpellMgr->GetSpellInfo(SPELL_CHAIN_LIGHTNING) || !sSpellMgr->GetSpellInfo(SPELL_ENVELOPING_WINDS)) + return false; + return true; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + { + uint32 spellId = 0; + uint32 rand = urand(0, 99); + if (rand < 25) // Fireball (25% chance) + spellId = SPELL_FIREBALL; + else if (rand < 50) // Frostball (25% chance) + spellId = SPELL_FROSTBOLT; + else if (rand < 70) // Chain Lighting (20% chance) + spellId = SPELL_CHAIN_LIGHTNING; + else if (rand < 80) // Polymorph (10% chance) + { + spellId = SPELL_POLYMORPH; + if (urand(0, 100) <= 30) // 30% chance to self-cast + target = caster; + } + else if (rand < 95) // Enveloping Winds (15% chance) + spellId = SPELL_ENVELOPING_WINDS; + else // Summon Felhund minion (5% chance) + { + spellId = SPELL_SUMMON_FELHOUND_MINION; + target = caster; + } + + caster->CastSpell(target, spellId, true, GetCastItem()); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_six_demon_bag_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_item_six_demon_bag_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_six_demon_bag_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_six_demon_bag_SpellScript(); - } }; // http://www.wowhead.com/item=44012 Underbelly Elixir // 59640 Underbelly Elixir -enum eUnderbellyElixirSpells +enum UnderbellyElixirSpells { SPELL_UNDERBELLY_ELIXIR_TRIGGERED1 = 59645, SPELL_UNDERBELLY_ELIXIR_TRIGGERED2 = 59831, @@ -625,49 +600,46 @@ enum eUnderbellyElixirSpells class spell_item_underbelly_elixir : public SpellScriptLoader { -public: - spell_item_underbelly_elixir() : SpellScriptLoader("spell_item_underbelly_elixir") { } - - class spell_item_underbelly_elixir_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_item_underbelly_elixir_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED1)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED2)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED3)) - return false; - return true; - } + spell_item_underbelly_elixir() : SpellScriptLoader("spell_item_underbelly_elixir") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_item_underbelly_elixir_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; + PrepareSpellScript(spell_item_underbelly_elixir_SpellScript); - uint32 spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED3; - switch (urand(1, 3)) + bool Load() { - case 1: spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED1; break; - case 2: spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED2; break; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED1) || !sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED2) || !sSpellMgr->GetSpellInfo(SPELL_UNDERBELLY_ELIXIR_TRIGGERED3)) + return false; + return true; } - pCaster->CastSpell(pCaster, spellId, true, NULL); - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED3; + switch (urand(1, 3)) + { + case 1: spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED1; break; + case 2: spellId = SPELL_UNDERBELLY_ELIXIR_TRIGGERED2; break; + } + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_item_underbelly_elixir_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_item_underbelly_elixir_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_item_underbelly_elixir_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_item_underbelly_elixir_SpellScript(); - } }; enum eShadowmourneVisuals @@ -684,17 +656,11 @@ public: class spell_item_shadowmourne_AuraScript : public AuraScript { - public: - PrepareAuraScript(spell_item_shadowmourne_AuraScript) - spell_item_shadowmourne_AuraScript() : AuraScript() { } + PrepareAuraScript(spell_item_shadowmourne_AuraScript); bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_VISUAL_LOW)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_VISUAL_HIGH)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_CHAOS_BANE_BUFF)) + if (!sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_VISUAL_LOW) || !sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_VISUAL_HIGH) || !sSpellMgr->GetSpellInfo(SPELL_SHADOWMOURNE_CHAOS_BANE_BUFF)) return false; return true; } @@ -702,7 +668,6 @@ public: void OnStackChange(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { Unit* target = GetTarget(); - switch (GetStackAmount()) { case 1: @@ -716,6 +681,8 @@ public: target->RemoveAurasDueToSpell(SPELL_SHADOWMOURNE_VISUAL_HIGH); target->CastSpell(target, SPELL_SHADOWMOURNE_CHAOS_BANE_BUFF, true); break; + default: + break; } } @@ -757,11 +724,7 @@ class spell_item_red_rider_air_rifle : public SpellScriptLoader bool Validate(SpellInfo const* /*spell*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_HOLD_VISUAL)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_SHOOT)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_SHOOT_SELF)) + if (!sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_HOLD_VISUAL) || !sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_SHOOT) || !sSpellMgr->GetSpellInfo(SPELL_AIR_RIFLE_SHOOT_SELF)) return false; return true; } @@ -769,17 +732,18 @@ class spell_item_red_rider_air_rifle : public SpellScriptLoader void HandleScript(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - if (!GetHitUnit()) - return; - - GetCaster()->CastSpell(GetCaster(), SPELL_AIR_RIFLE_HOLD_VISUAL, true); - // needed because this spell shares GCD with its triggered spells (which must not be cast with triggered flag) - if (Player* player = GetCaster()->ToPlayer()) - player->GetGlobalCooldownMgr().CancelGlobalCooldown(GetSpellInfo()); - if (urand(0, 4)) - GetCaster()->CastSpell(GetHitUnit(), SPELL_AIR_RIFLE_SHOOT, false); - else - GetCaster()->CastSpell(GetCaster(), SPELL_AIR_RIFLE_SHOOT_SELF, false); + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + { + caster->CastSpell(caster, SPELL_AIR_RIFLE_HOLD_VISUAL, true); + // needed because this spell shares GCD with its triggered spells (which must not be cast with triggered flag) + if (Player* player = caster->ToPlayer()) + player->GetGlobalCooldownMgr().CancelGlobalCooldown(GetSpellInfo()); + if (urand(0, 4)) + caster->CastSpell(target, SPELL_AIR_RIFLE_SHOOT, false); + else + caster->CastSpell(caster, SPELL_AIR_RIFLE_SHOOT_SELF, false); + } } void Register() @@ -794,7 +758,7 @@ class spell_item_red_rider_air_rifle : public SpellScriptLoader } }; -enum eGenericData +enum GenericData { SPELL_ARCANITE_DRAGONLING = 19804, SPELL_BATTLE_CHICKEN = 13166, @@ -826,14 +790,11 @@ class spell_item_create_heart_candy : public SpellScriptLoader void HandleScript(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - if (!GetHitUnit() || !GetHitUnit()->ToPlayer()) - return; - - Player* target = GetHitUnit()->ToPlayer(); - - static const uint32 items[] = {ITEM_HEART_CANDY_1, ITEM_HEART_CANDY_2, ITEM_HEART_CANDY_3, ITEM_HEART_CANDY_4, ITEM_HEART_CANDY_5, ITEM_HEART_CANDY_6, ITEM_HEART_CANDY_7, ITEM_HEART_CANDY_8}; - - target->AddItem(items[urand(0, 7)], 1); + if (Player* target = GetHitPlayer()) + { + static const uint32 items[] = {ITEM_HEART_CANDY_1, ITEM_HEART_CANDY_2, ITEM_HEART_CANDY_3, ITEM_HEART_CANDY_4, ITEM_HEART_CANDY_5, ITEM_HEART_CANDY_6, ITEM_HEART_CANDY_7, ITEM_HEART_CANDY_8}; + target->AddItem(items[urand(0, 7)], 1); + } } void Register() @@ -857,9 +818,14 @@ class spell_item_book_of_glyph_mastery : public SpellScriptLoader { PrepareSpellScript(spell_item_book_of_glyph_mastery_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + SpellCastResult CheckRequirement() { - if (GetCaster()->GetTypeId() == TYPEID_PLAYER && HasDiscoveredAllSpells(GetSpellInfo()->Id, GetCaster()->ToPlayer())) + if (HasDiscoveredAllSpells(GetSpellInfo()->Id, GetCaster()->ToPlayer())) { SetCustomCastResultMessage(SPELL_CUSTOM_ERROR_LEARNED_EVERYTHING); return SPELL_FAILED_CUSTOM_ERROR; @@ -939,7 +905,7 @@ class spell_item_map_of_the_geyser_fields : public SpellScriptLoader SpellCastResult CheckSinkholes() { Unit* caster = GetCaster(); - if (caster->FindNearestCreature(NPC_SOUTH_SINKHOLE, 30.0f, true) || + if (caster->FindNearestCreature(NPC_SOUTH_SINKHOLE, 30.0f, true) || caster->FindNearestCreature(NPC_NORTHEAST_SINKHOLE, 30.0f, true) || caster->FindNearestCreature(NPC_NORTHWEST_SINKHOLE, 30.0f, true)) return SPELL_CAST_OK; @@ -978,11 +944,7 @@ class spell_item_vanquished_clutches : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_CRUSHER)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_CONSTRICTOR)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_CORRUPTOR)) + if (!sSpellMgr->GetSpellInfo(SPELL_CRUSHER) || !sSpellMgr->GetSpellInfo(SPELL_CONSTRICTOR) || !sSpellMgr->GetSpellInfo(SPELL_CORRUPTOR)) return false; return true; } @@ -990,7 +952,8 @@ class spell_item_vanquished_clutches : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { uint32 spellId = RAND(SPELL_CRUSHER, SPELL_CONSTRICTOR, SPELL_CORRUPTOR); - GetCaster()->CastSpell(GetCaster(), spellId, true); + Unit* caster = GetCaster(); + caster->CastSpell(caster, spellId, true); } void Register() @@ -1019,9 +982,6 @@ enum AshbringerSounds SOUND_ASHBRINGER_10 = 8926, // "Scarlet Crusade is pure no longer" SOUND_ASHBRINGER_11 = 8927, // "Balnazzar's crusade corrupted my son" SOUND_ASHBRINGER_12 = 8928, // "Kill them all!" - - SPELL_ASHBRINGER = 28282, // Ashbringer - Inflicts the will of the Ashbringer upon the wielder - SPELL_ASHBRINGER_TR = 28441 // AB Effect 000 }; class spell_item_ashbringer : public SpellScriptLoader @@ -1031,28 +991,24 @@ class spell_item_ashbringer : public SpellScriptLoader class spell_item_ashbringer_SpellScript : public SpellScript { - PrepareSpellScript(spell_item_ashbringer_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + PrepareSpellScript(spell_item_ashbringer_SpellScript); + + bool Load() { - if (!sSpellMgr->GetSpellInfo(SPELL_ASHBRINGER)) - return false; - return true; + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } void OnDummyEffect(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - Unit* caster = GetCaster(); - if (Player* player = caster->ToPlayer()) - { - uint32 sound_id = RAND( SOUND_ASHBRINGER_1, SOUND_ASHBRINGER_2, SOUND_ASHBRINGER_3, SOUND_ASHBRINGER_4, SOUND_ASHBRINGER_5, SOUND_ASHBRINGER_6, - SOUND_ASHBRINGER_7, SOUND_ASHBRINGER_8, SOUND_ASHBRINGER_9, SOUND_ASHBRINGER_10, SOUND_ASHBRINGER_11, SOUND_ASHBRINGER_12 ); + Player* player = GetCaster()->ToPlayer(); + uint32 sound_id = RAND( SOUND_ASHBRINGER_1, SOUND_ASHBRINGER_2, SOUND_ASHBRINGER_3, SOUND_ASHBRINGER_4, SOUND_ASHBRINGER_5, SOUND_ASHBRINGER_6, + SOUND_ASHBRINGER_7, SOUND_ASHBRINGER_8, SOUND_ASHBRINGER_9, SOUND_ASHBRINGER_10, SOUND_ASHBRINGER_11, SOUND_ASHBRINGER_12 ); - // Ashbringers effect (spellID 28441) retriggers every 5 seconds, with a chance of making it say one of the above 12 sounds - if (urand(0, 60) < 1) - player->PlayDirectSound(sound_id, player); - } + // Ashbringers effect (spellID 28441) retriggers every 5 seconds, with a chance of making it say one of the above 12 sounds + if (urand(0, 60) < 1) + player->PlayDirectSound(sound_id, player); } void Register() @@ -1080,9 +1036,7 @@ enum MagicEater class spell_magic_eater_food : public SpellScriptLoader { public: - spell_magic_eater_food() : SpellScriptLoader("spell_magic_eater_food") - { - } + spell_magic_eater_food() : SpellScriptLoader("spell_magic_eater_food") {} class spell_magic_eater_food_AuraScript : public AuraScript { @@ -1092,7 +1046,6 @@ class spell_magic_eater_food : public SpellScriptLoader { PreventDefaultAction(); Unit* target = GetTarget(); - switch (urand(0, 5)) { case 0: @@ -1113,7 +1066,7 @@ class spell_magic_eater_food : public SpellScriptLoader case 5: target->CastSpell(target, SPELL_WELL_FED_5, true); break; - } + } } void Register() @@ -1128,6 +1081,870 @@ class spell_magic_eater_food : public SpellScriptLoader } }; +class spell_item_shimmering_vessel : public SpellScriptLoader +{ + public: + spell_item_shimmering_vessel() : SpellScriptLoader("spell_item_shimmering_vessel") { } + + class spell_item_shimmering_vessel_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_shimmering_vessel_SpellScript); + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (Creature* target = GetHitCreature()) + target->setDeathState(JUST_ALIVED); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_shimmering_vessel_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_shimmering_vessel_SpellScript(); + } +}; + +enum PurifyHelboarMeat +{ + SPELL_SUMMON_PURIFIED_HELBOAR_MEAT = 29277, + SPELL_SUMMON_TOXIC_HELBOAR_MEAT = 29278, +}; + +class spell_item_purify_helboar_meat : public SpellScriptLoader +{ + public: + spell_item_purify_helboar_meat() : SpellScriptLoader("spell_item_purify_helboar_meat") { } + + class spell_item_purify_helboar_meat_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_purify_helboar_meat_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_PURIFIED_HELBOAR_MEAT) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_TOXIC_HELBOAR_MEAT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + caster->CastSpell(caster, roll_chance_i(50) ? SPELL_SUMMON_PURIFIED_HELBOAR_MEAT : SPELL_SUMMON_TOXIC_HELBOAR_MEAT, true, NULL); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_purify_helboar_meat_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_purify_helboar_meat_SpellScript(); + } +}; + +enum CrystalPrison +{ + OBJECT_IMPRISONED_DOOMGUARD = 179644, +}; + +class spell_item_crystal_prison_dummy_dnd : public SpellScriptLoader +{ + public: + spell_item_crystal_prison_dummy_dnd() : SpellScriptLoader("spell_item_crystal_prison_dummy_dnd") { } + + class spell_item_crystal_prison_dummy_dnd_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_crystal_prison_dummy_dnd_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sObjectMgr->GetGameObjectTemplate(OBJECT_IMPRISONED_DOOMGUARD)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (Creature* target = GetHitCreature()) + if (target->isDead() && !target->isPet()) + { + GetCaster()->SummonGameObject(OBJECT_IMPRISONED_DOOMGUARD, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), target->GetOrientation(), 0, 0, 0, 0, uint32(target->GetRespawnTime()-time(NULL))); + target->DespawnOrUnsummon(); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_crystal_prison_dummy_dnd_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_crystal_prison_dummy_dnd_SpellScript(); + } +}; + +enum ReindeerTransformation +{ + SPELL_FLYING_REINDEER_310 = 44827, + SPELL_FLYING_REINDEER_280 = 44825, + SPELL_FLYING_REINDEER_60 = 44824, + SPELL_REINDEER_100 = 25859, + SPELL_REINDEER_60 = 25858, +}; + +class spell_item_reindeer_transformation : public SpellScriptLoader +{ + public: + spell_item_reindeer_transformation() : SpellScriptLoader("spell_item_reindeer_transformation") { } + + class spell_item_reindeer_transformation_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_reindeer_transformation_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_FLYING_REINDEER_310) || !sSpellMgr->GetSpellInfo(SPELL_FLYING_REINDEER_280) + || !sSpellMgr->GetSpellInfo(SPELL_FLYING_REINDEER_60) || !sSpellMgr->GetSpellInfo(SPELL_REINDEER_100) + || !sSpellMgr->GetSpellInfo(SPELL_REINDEER_60)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (caster->HasAuraType(SPELL_AURA_MOUNTED)) + { + float flyspeed = caster->GetSpeedRate(MOVE_FLIGHT); + float speed = caster->GetSpeedRate(MOVE_RUN); + + caster->RemoveAurasByType(SPELL_AURA_MOUNTED); + //5 different spells used depending on mounted speed and if mount can fly or not + + if (flyspeed >= 4.1f) + // Flying Reindeer + caster->CastSpell(caster, SPELL_FLYING_REINDEER_310, true); //310% flying Reindeer + else if (flyspeed >= 3.8f) + // Flying Reindeer + caster->CastSpell(caster, SPELL_FLYING_REINDEER_280, true); //280% flying Reindeer + else if (flyspeed >= 1.6f) + // Flying Reindeer + caster->CastSpell(caster, SPELL_FLYING_REINDEER_60, true); //60% flying Reindeer + else if (speed >= 2.0f) + // Reindeer + caster->CastSpell(caster, SPELL_REINDEER_100, true); //100% ground Reindeer + else + // Reindeer + caster->CastSpell(caster, SPELL_REINDEER_60, true); //60% ground Reindeer + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_reindeer_transformation_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_reindeer_transformation_SpellScript(); + } +}; + +enum NighInvulnerability +{ + SPELL_NIGH_INVULNERABILITY = 30456, + SPELL_COMPLETE_VULNERABILITY = 30457, +}; + +class spell_item_nigh_invulnerability : public SpellScriptLoader +{ + public: + spell_item_nigh_invulnerability() : SpellScriptLoader("spell_item_nigh_invulnerability") { } + + class spell_item_nigh_invulnerability_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_nigh_invulnerability_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_NIGH_INVULNERABILITY) || !sSpellMgr->GetSpellInfo(SPELL_COMPLETE_VULNERABILITY)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (Item* castItem = GetCastItem()) + if (roll_chance_i(86)) // Nigh-Invulnerability - success + caster->CastSpell(caster, SPELL_NIGH_INVULNERABILITY, true, castItem); + else // Complete Vulnerability - backfire in 14% casts + caster->CastSpell(caster, SPELL_COMPLETE_VULNERABILITY, true, castItem); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_nigh_invulnerability_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_nigh_invulnerability_SpellScript(); + } +}; + +enum Poultryzer +{ + SPELL_POULTRYIZER_SUCCESS = 30501, + SPELL_POULTRYIZER_BACKFIRE = 30504, +}; + +class spell_item_poultryizer : public SpellScriptLoader +{ + public: + spell_item_poultryizer() : SpellScriptLoader("spell_item_poultryizer") { } + + class spell_item_poultryizer_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_poultryizer_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_POULTRYIZER_SUCCESS) || !sSpellMgr->GetSpellInfo(SPELL_POULTRYIZER_BACKFIRE)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (GetCastItem() && GetHitUnit()) + GetCaster()->CastSpell(GetHitUnit(), roll_chance_i(80) ? SPELL_POULTRYIZER_SUCCESS : SPELL_POULTRYIZER_BACKFIRE , true, GetCastItem()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_poultryizer_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_poultryizer_SpellScript(); + } +}; + +enum SocretharsStone +{ + SPELL_SOCRETHAR_TO_SEAT = 35743, + SPELL_SOCRETHAR_FROM_SEAT = 35744, +}; + +class spell_item_socrethars_stone : public SpellScriptLoader +{ + public: + spell_item_socrethars_stone() : SpellScriptLoader("spell_item_socrethars_stone") { } + + class spell_item_socrethars_stone_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_socrethars_stone_SpellScript); + + bool Load() + { + return (GetCaster()->GetAreaId() == 3900 || GetCaster()->GetAreaId() == 3742); + } + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_SOCRETHAR_TO_SEAT) || !sSpellMgr->GetSpellInfo(SPELL_SOCRETHAR_FROM_SEAT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + switch (caster->GetAreaId()) + { + case 3900: + caster->CastSpell(caster, SPELL_SOCRETHAR_TO_SEAT, true); + break; + case 3742: + caster->CastSpell(caster, SPELL_SOCRETHAR_FROM_SEAT, true); + break; + default: + return; + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_socrethars_stone_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_socrethars_stone_SpellScript(); + } +}; + +enum DemonBroiledSurprise +{ + QUEST_SUPER_HOT_STEW = 11379, + SPELL_CREATE_DEMON_BROILED_SURPRISE = 43753, + NPC_ABYSSAL_FLAMEBRINGER = 19973, +}; + +class spell_item_demon_broiled_surprise : public SpellScriptLoader +{ + public: + spell_item_demon_broiled_surprise() : SpellScriptLoader("spell_item_demon_broiled_surprise") { } + + class spell_item_demon_broiled_surprise_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_demon_broiled_surprise_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_CREATE_DEMON_BROILED_SURPRISE) || !sObjectMgr->GetCreatureTemplate(NPC_ABYSSAL_FLAMEBRINGER) || !sObjectMgr->GetQuestTemplate(QUEST_SUPER_HOT_STEW)) + return false; + return true; + } + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* player = GetCaster(); + player->CastSpell(player, SPELL_CREATE_DEMON_BROILED_SURPRISE, false); + } + + SpellCastResult CheckRequirement() + { + Player* player = GetCaster()->ToPlayer(); + if (player->GetQuestStatus(QUEST_SUPER_HOT_STEW) != QUEST_STATUS_INCOMPLETE) + return SPELL_FAILED_CANT_DO_THAT_RIGHT_NOW; + + if (Creature* creature = player->FindNearestCreature(NPC_ABYSSAL_FLAMEBRINGER, 10, false)) + if (creature->isDead()) + return SPELL_CAST_OK; + return SPELL_FAILED_NOT_HERE; + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_demon_broiled_surprise_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY); + OnCheckCast += SpellCheckCastFn(spell_item_demon_broiled_surprise_SpellScript::CheckRequirement); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_demon_broiled_surprise_SpellScript(); + } +}; + +enum CompleteRaptorCapture +{ + SPELL_RAPTOR_CAPTURE_CREDIT = 42337, +}; + +class spell_item_complete_raptor_capture : public SpellScriptLoader +{ + public: + spell_item_complete_raptor_capture() : SpellScriptLoader("spell_item_complete_raptor_capture") { } + + class spell_item_complete_raptor_capture_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_complete_raptor_capture_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_RAPTOR_CAPTURE_CREDIT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (GetHitCreature()) + { + GetHitCreature()->DespawnOrUnsummon(); + + //cast spell Raptor Capture Credit + caster->CastSpell(caster, SPELL_RAPTOR_CAPTURE_CREDIT, true, NULL); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_complete_raptor_capture_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_complete_raptor_capture_SpellScript(); + } +}; + +enum ImpaleLeviroth +{ + NPC_LEVIROTH = 26452, + SPELL_LEVIROTH_SELF_IMPALE = 49882 +}; + +class spell_item_impale_leviroth : public SpellScriptLoader +{ + public: + spell_item_impale_leviroth() : SpellScriptLoader("spell_item_impale_leviroth") { } + + class spell_item_impale_leviroth_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_impale_leviroth_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sObjectMgr->GetCreatureTemplate(NPC_LEVIROTH)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* target = GetHitCreature(); + if (!target || target->GetEntry() != NPC_LEVIROTH || !target->HealthBelowPct(95)) + return; + + target->CastSpell(target, SPELL_LEVIROTH_SELF_IMPALE, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_impale_leviroth_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_impale_leviroth_SpellScript(); + } +}; + +enum BrewfestMountTransformation +{ + SPELL_MOUNT_RAM_100 = 43900, + SPELL_MOUNT_RAM_60 = 43899, + SPELL_MOUNT_KODO_100 = 49379, + SPELL_MOUNT_KODO_60 = 49378, + SPELL_BREWFEST_MOUNT_TRANSFORM = 49357, + SPELL_BREWFEST_MOUNT_TRANSFORM_REVERSE = 52845, +}; + +class spell_item_brewfest_mount_transformation : public SpellScriptLoader +{ + public: + spell_item_brewfest_mount_transformation() : SpellScriptLoader("spell_item_brewfest_mount_transformation") { } + + class spell_item_brewfest_mount_transformation_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_brewfest_mount_transformation_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_MOUNT_RAM_100) || !sSpellMgr->GetSpellInfo(SPELL_MOUNT_RAM_60) || !sSpellMgr->GetSpellInfo(SPELL_MOUNT_KODO_100) || !sSpellMgr->GetSpellInfo(SPELL_MOUNT_KODO_60)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Player* caster = GetCaster()->ToPlayer(); + if (caster->HasAuraType(SPELL_AURA_MOUNTED)) + { + caster->RemoveAurasByType(SPELL_AURA_MOUNTED); + uint32 spell_id; + + switch (GetSpellInfo()->Id) + { + case SPELL_BREWFEST_MOUNT_TRANSFORM: + if (caster->GetSpeedRate(MOVE_RUN) >= 2.0f) + spell_id = caster->GetTeam() == ALLIANCE ? SPELL_MOUNT_RAM_100 : SPELL_MOUNT_KODO_100 ; + else + spell_id = caster->GetTeam() == ALLIANCE ? SPELL_MOUNT_RAM_60 : SPELL_MOUNT_KODO_60 ; + break; + case SPELL_BREWFEST_MOUNT_TRANSFORM_REVERSE: + if (caster->GetSpeedRate(MOVE_RUN) >= 2.0f) + spell_id = caster->GetTeam() == HORDE ? SPELL_MOUNT_RAM_100 : SPELL_MOUNT_KODO_100 ; + else + spell_id = caster->GetTeam() == HORDE ? SPELL_MOUNT_RAM_60 : SPELL_MOUNT_KODO_60 ; + break; + default: + return; + } + caster->CastSpell(caster, spell_id, true); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_brewfest_mount_transformation_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_brewfest_mount_transformation_SpellScript(); + } +}; + +enum NitroBoots +{ + SPELL_NITRO_BOOTS_SUCCESS = 54861, + SPELL_NITRO_BOOTS_BACKFIRE = 46014, +}; + +class spell_item_nitro_boots : public SpellScriptLoader +{ + public: + spell_item_nitro_boots() : SpellScriptLoader("spell_item_nitro_boots") { } + + class spell_item_nitro_boots_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_nitro_boots_SpellScript); + + bool Load() + { + if (!GetCastItem()) + return false; + return true; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_NITRO_BOOTS_SUCCESS) || !sSpellMgr->GetSpellInfo(SPELL_NITRO_BOOTS_BACKFIRE)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + caster->CastSpell(caster, roll_chance_i(95) ? SPELL_NITRO_BOOTS_SUCCESS : SPELL_NITRO_BOOTS_BACKFIRE, true, GetCastItem()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_nitro_boots_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_nitro_boots_SpellScript(); + } +}; + +enum TeachLanguage +{ + SPELL_LEARN_GNOMISH_BINARY = 50242, + SPELL_LEARN_GOBLIN_BINARY = 50246, +}; + +class spell_item_teach_language : public SpellScriptLoader +{ + public: + spell_item_teach_language() : SpellScriptLoader("spell_item_teach_language") { } + + class spell_item_teach_language_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_teach_language_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_LEARN_GNOMISH_BINARY) || !sSpellMgr->GetSpellInfo(SPELL_LEARN_GOBLIN_BINARY)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Player* caster = GetCaster()->ToPlayer(); + + if (roll_chance_i(34)) + caster->CastSpell(caster,caster->GetTeam() == ALLIANCE ? SPELL_LEARN_GNOMISH_BINARY : SPELL_LEARN_GOBLIN_BINARY, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_teach_language_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_teach_language_SpellScript(); + } +}; + +enum RocketBoots +{ + SPELL_ROCKET_BOOTS_PROC = 30452, +}; + +class spell_item_rocket_boots : public SpellScriptLoader +{ + public: + spell_item_rocket_boots() : SpellScriptLoader("spell_item_rocket_boots") { } + + class spell_item_rocket_boots_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_rocket_boots_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_ROCKET_BOOTS_PROC)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Player* caster = GetCaster()->ToPlayer(); + if (Battleground* bg = caster->GetBattleground()) + bg->EventPlayerDroppedFlag(caster); + + caster->CastSpell(caster, SPELL_ROCKET_BOOTS_PROC, true, NULL); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_rocket_boots_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_rocket_boots_SpellScript(); + } +}; + +enum PygmyOil +{ + SPELL_PYGMY_OIL_PYGMY_AURA = 53806, + SPELL_PYGMY_OIL_SMALLER_AURA = 53805, +}; + +class spell_item_pygmy_oil : public SpellScriptLoader +{ + public: + spell_item_pygmy_oil() : SpellScriptLoader("spell_item_pygmy_oil") { } + + class spell_item_pygmy_oil_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_pygmy_oil_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_PYGMY_OIL_PYGMY_AURA) || !sSpellMgr->GetSpellInfo(SPELL_PYGMY_OIL_SMALLER_AURA)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + if (Aura* aura = caster->GetAura(SPELL_PYGMY_OIL_PYGMY_AURA)) + aura->RefreshDuration(); + else + { + aura = caster->GetAura(SPELL_PYGMY_OIL_SMALLER_AURA); + if (!aura || aura->GetStackAmount() < 5 || !roll_chance_i(50)) + caster->CastSpell(caster, SPELL_PYGMY_OIL_SMALLER_AURA, true); + else + { + aura->Remove(); + caster->CastSpell(caster, SPELL_PYGMY_OIL_PYGMY_AURA, true); + } + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_pygmy_oil_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_pygmy_oil_SpellScript(); + } +}; + +class spell_item_unusual_compass : public SpellScriptLoader +{ + public: + spell_item_unusual_compass() : SpellScriptLoader("spell_item_unusual_compass") { } + + class spell_item_unusual_compass_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_unusual_compass_SpellScript); + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + caster->SetOrientation(frand(0.0f, 62832.0f) / 10000.0f); + caster->SendMovementFlagUpdate(); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_unusual_compass_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_unusual_compass_SpellScript(); + } +}; + +enum UDED +{ + NPC_IRONWOOL_MAMMOTH = 53806, + SPELL_MAMMOTH_CARCASS = 57444, + SPELL_MAMMOTH_MEAT = 54625, +}; + +class spell_item_uded : public SpellScriptLoader +{ + public: + spell_item_uded() : SpellScriptLoader("spell_item_uded") { } + + class spell_item_uded_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_uded_SpellScript); + + bool Load() + { + if (GetHitCreature() && GetHitCreature()->GetEntry() == NPC_IRONWOOL_MAMMOTH) + return true; + return false; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_MAMMOTH_CARCASS) || !sSpellMgr->GetSpellInfo(SPELL_MAMMOTH_MEAT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Unit* caster = GetCaster(); + Creature* creature = GetHitCreature(); + caster->CastSpell(caster,SPELL_MAMMOTH_CARCASS,true); + + for (uint8 i = 0; i < 4; ++i) + caster->CastSpell(caster,SPELL_MAMMOTH_MEAT,true); + + creature->Kill(creature); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_uded_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_uded_SpellScript(); + } +}; + +enum ChickenCover +{ + SPELL_CHICKEN_NET = 51959, + SPELL_CAPTURE_CHICKEN_ESCAPE = 51037, + QUEST_CHICKEN_PARTY = 12702, + QUEST_FLOWN_THE_COOP = 12532, +}; + +class spell_item_chicken_cover : public SpellScriptLoader +{ + public: + spell_item_chicken_cover() : SpellScriptLoader("spell_item_chicken_cover") { } + + class spell_item_chicken_cover_SpellScript : public SpellScript + { + PrepareSpellScript(spell_item_chicken_cover_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_CHICKEN_NET) || !sSpellMgr->GetSpellInfo(SPELL_CAPTURE_CHICKEN_ESCAPE) || !sObjectMgr->GetQuestTemplate(QUEST_CHICKEN_PARTY) || !sObjectMgr->GetQuestTemplate(QUEST_FLOWN_THE_COOP)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + Player* caster = GetCaster()->ToPlayer(); + if (Unit* target = GetHitUnit()) + { + if (!target->HasAura(SPELL_CHICKEN_NET) && (caster->GetQuestStatus(QUEST_CHICKEN_PARTY) == QUEST_STATUS_INCOMPLETE || caster->GetQuestStatus(QUEST_FLOWN_THE_COOP) == QUEST_STATUS_INCOMPLETE)) + { + caster->CastSpell(caster, SPELL_CAPTURE_CHICKEN_ESCAPE, true); + target->Kill(target); + } + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_item_chicken_cover_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_item_chicken_cover_SpellScript(); + } +}; + enum Refocus { SPELL_AIMED_SHOT = 19434, @@ -1206,4 +2023,22 @@ void AddSC_item_spell_scripts() new spell_item_ashbringer(); new spell_magic_eater_food(); new spell_item_refocus(); + new spell_item_shimmering_vessel(); + new spell_item_purify_helboar_meat(); + new spell_item_crystal_prison_dummy_dnd(); + new spell_item_reindeer_transformation(); + new spell_item_nigh_invulnerability(); + new spell_item_poultryizer(); + new spell_item_socrethars_stone(); + new spell_item_demon_broiled_surprise(); + new spell_item_complete_raptor_capture(); + new spell_item_impale_leviroth(); + new spell_item_brewfest_mount_transformation(); + new spell_item_nitro_boots(); + new spell_item_teach_language(); + new spell_item_rocket_boots(); + new spell_item_pygmy_oil(); + new spell_item_unusual_compass(); + new spell_item_uded(); + new spell_item_chicken_cover(); } diff --git a/src/server/scripts/Spells/spell_mage.cpp b/src/server/scripts/Spells/spell_mage.cpp index b0b619c8b..ea1af1081 100644 --- a/src/server/scripts/Spells/spell_mage.cpp +++ b/src/server/scripts/Spells/spell_mage.cpp @@ -21,7 +21,10 @@ * Scriptnames of files in this file should be prefixed with "spell_mage_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" +#include "SpellAuraEffects.h" + enum MageSpells { @@ -45,7 +48,8 @@ class spell_mage_blast_wave : public SpellScriptLoader class spell_mage_blast_wave_SpellScript : public SpellScript { - PrepareSpellScript(spell_mage_blast_wave_SpellScript) + PrepareSpellScript(spell_mage_blast_wave_SpellScript); + bool Validate(SpellInfo const* /*spellEntry*/) { if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_GLYPH_OF_BLAST_WAVE)) @@ -78,16 +82,19 @@ class spell_mage_cold_snap : public SpellScriptLoader class spell_mage_cold_snap_SpellScript : public SpellScript { - PrepareSpellScript(spell_mage_cold_snap_SpellScript) + PrepareSpellScript(spell_mage_cold_snap_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleDummy(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - - if (caster->GetTypeId() != TYPEID_PLAYER) - return; + Player* caster = GetCaster()->ToPlayer(); // immediately finishes the cooldown on Frost spells - const SpellCooldowns& cm = caster->ToPlayer()->GetSpellCooldownMap(); + const SpellCooldowns& cm = caster->GetSpellCooldownMap(); for (SpellCooldowns::const_iterator itr = cm.begin(); itr != cm.end();) { SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first); @@ -96,7 +103,7 @@ class spell_mage_cold_snap : public SpellScriptLoader (spellInfo->GetSchoolMask() & SPELL_SCHOOL_MASK_FROST) && spellInfo->Id != SPELL_MAGE_COLD_SNAP && spellInfo->GetRecoveryTime() > 0) { - caster->ToPlayer()->RemoveSpellCooldown((itr++)->first, true); + caster->RemoveSpellCooldown((itr++)->first, true); } else ++itr; @@ -123,7 +130,8 @@ class spell_mage_polymorph_cast_visual : public SpellScriptLoader class spell_mage_polymorph_cast_visual_SpellScript : public SpellScript { - PrepareSpellScript(spell_mage_polymorph_cast_visual_SpellScript) + PrepareSpellScript(spell_mage_polymorph_cast_visual_SpellScript); + static const uint32 spell_list[6]; bool Validate(SpellInfo const* /*spellEntry*/) @@ -172,14 +180,11 @@ class spell_mage_summon_water_elemental : public SpellScriptLoader class spell_mage_summon_water_elemental_SpellScript : public SpellScript { - PrepareSpellScript(spell_mage_summon_water_elemental_SpellScript) + PrepareSpellScript(spell_mage_summon_water_elemental_SpellScript); + bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_GLYPH_OF_ETERNAL_WATER)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_SUMMON_WATER_ELEMENTAL_TEMPORARY)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_SUMMON_WATER_ELEMENTAL_PERMANENT)) + if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_GLYPH_OF_ETERNAL_WATER) || !sSpellMgr->GetSpellInfo(SPELL_MAGE_SUMMON_WATER_ELEMENTAL_TEMPORARY) || !sSpellMgr->GetSpellInfo(SPELL_MAGE_SUMMON_WATER_ELEMENTAL_PERMANENT)) return false; return true; } @@ -210,78 +215,79 @@ class spell_mage_summon_water_elemental : public SpellScriptLoader // Frost Warding class spell_mage_frost_warding_trigger : public SpellScriptLoader { -public: - spell_mage_frost_warding_trigger() : SpellScriptLoader("spell_mage_frost_warding_trigger") { } + public: + spell_mage_frost_warding_trigger() : SpellScriptLoader("spell_mage_frost_warding_trigger") { } - class spell_mage_frost_warding_trigger_AuraScript : public AuraScript - { - PrepareAuraScript(spell_mage_frost_warding_trigger_AuraScript); - - enum Spells + class spell_mage_frost_warding_trigger_AuraScript : public AuraScript { - SPELL_MAGE_FROST_WARDING_TRIGGERED = 57776, - SPELL_MAGE_FROST_WARDING_R1 = 28332, - }; + PrepareAuraScript(spell_mage_frost_warding_trigger_AuraScript); - bool Validate(SpellInfo const* /*spellEntry*/) - { - return sSpellMgr->GetSpellInfo(SPELL_MAGE_FROST_WARDING_TRIGGERED) - && sSpellMgr->GetSpellInfo(SPELL_MAGE_FROST_WARDING_R1); - } - - void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount) - { - Unit* target = GetTarget(); - if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_FROST_WARDING_R1, EFFECT_0)) + enum Spells { - int32 chance = talentAurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + SPELL_MAGE_FROST_WARDING_TRIGGERED = 57776, + SPELL_MAGE_FROST_WARDING_R1 = 28332, + }; - if (roll_chance_i(chance)) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_MAGE_FROST_WARDING_TRIGGERED) || !sSpellMgr->GetSpellInfo(SPELL_MAGE_FROST_WARDING_R1)) + return false; + return true; + } + + void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount) + { + Unit* target = GetTarget(); + if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_FROST_WARDING_R1, EFFECT_0)) { - absorbAmount = dmgInfo.GetDamage(); - int32 bp = absorbAmount; - target->CastCustomSpell(target, SPELL_MAGE_FROST_WARDING_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); + int32 chance = talentAurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + + if (roll_chance_i(chance)) + { + absorbAmount = dmgInfo.GetDamage(); + int32 bp = absorbAmount; + target->CastCustomSpell(target, SPELL_MAGE_FROST_WARDING_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); + } } } - } - void Register() + void Register() + { + OnEffectAbsorb += AuraEffectAbsorbFn(spell_mage_frost_warding_trigger_AuraScript::Absorb, EFFECT_0); + } + }; + + AuraScript* GetAuraScript() const { - OnEffectAbsorb += AuraEffectAbsorbFn(spell_mage_frost_warding_trigger_AuraScript::Absorb, EFFECT_0); + return new spell_mage_frost_warding_trigger_AuraScript(); } - }; - - AuraScript* GetAuraScript() const - { - return new spell_mage_frost_warding_trigger_AuraScript(); - } }; class spell_mage_incanters_absorbtion_base_AuraScript : public AuraScript { -public: - enum Spells - { - SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED = 44413, - SPELL_MAGE_INCANTERS_ABSORBTION_R1 = 44394, - }; - - bool Validate(SpellInfo const* /*spellEntry*/) - { - return sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED) - && sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_R1); - } - - void Trigger(AuraEffect* aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount) - { - Unit* target = GetTarget(); - - if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_INCANTERS_ABSORBTION_R1, EFFECT_0)) + public: + enum Spells { - int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount()); - target->CastCustomSpell(target, SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); + SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED = 44413, + SPELL_MAGE_INCANTERS_ABSORBTION_R1 = 44394, + }; + + bool Validate(SpellInfo const* /*spellEntry*/) + { + return sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED) + && sSpellMgr->GetSpellInfo(SPELL_MAGE_INCANTERS_ABSORBTION_R1); + } + + void Trigger(AuraEffect* aurEff, DamageInfo & /*dmgInfo*/, uint32 & absorbAmount) + { + Unit* target = GetTarget(); + + if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(SPELL_MAGE_INCANTERS_ABSORBTION_R1, EFFECT_0)) + { + int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount()); + target->CastCustomSpell(target, SPELL_MAGE_INCANTERS_ABSORBTION_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); + } } - } }; // Incanter's Absorption diff --git a/src/server/scripts/Spells/spell_paladin.cpp b/src/server/scripts/Spells/spell_paladin.cpp index 39360e04a..d823c629d 100644 --- a/src/server/scripts/Spells/spell_paladin.cpp +++ b/src/server/scripts/Spells/spell_paladin.cpp @@ -21,9 +21,11 @@ * Scriptnames of files in this file should be prefixed with "spell_pal_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" + enum PaladinSpells { PALADIN_SPELL_DIVINE_PLEA = 54428, @@ -46,323 +48,369 @@ enum PaladinSpells // 31850 - Ardent Defender class spell_pal_ardent_defender : public SpellScriptLoader { -public: - spell_pal_ardent_defender() : SpellScriptLoader("spell_pal_ardent_defender") { } + public: + spell_pal_ardent_defender() : SpellScriptLoader("spell_pal_ardent_defender") { } - class spell_pal_ardent_defender_AuraScript : public AuraScript - { - PrepareAuraScript(spell_pal_ardent_defender_AuraScript); - - uint32 absorbPct, healPct; - - enum Spell + class spell_pal_ardent_defender_AuraScript : public AuraScript { - PAL_SPELL_ARDENT_DEFENDER_HEAL = 66235, + PrepareAuraScript(spell_pal_ardent_defender_AuraScript); + + uint32 absorbPct, healPct; + + enum Spell + { + PAL_SPELL_ARDENT_DEFENDER_HEAL = 66235, + }; + + bool Load() + { + healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); + return GetUnitOwner()->GetTypeId() == TYPEID_PLAYER; + } + + void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) + { + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount) + { + Unit* victim = GetTarget(); + int32 remainingHealth = victim->GetHealth() - dmgInfo.GetDamage(); + uint32 allowedHealth = victim->CountPctFromMaxHealth(35); + // If damage kills us + if (remainingHealth <= 0 && !victim->ToPlayer()->HasSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL)) + { + // Cast healing spell, completely avoid damage + absorbAmount = dmgInfo.GetDamage(); + + uint32 defenseSkillValue = victim->GetDefenseSkillValue(); + // Max heal when defense skill denies critical hits from raid bosses + // Formula: max defense at level + 140 (raiting from gear) + uint32 reqDefForMaxHeal = victim->getLevel() * 5 + 140; + float pctFromDefense = (defenseSkillValue >= reqDefForMaxHeal) + ? 1.0f + : float(defenseSkillValue) / float(reqDefForMaxHeal); + + int32 healAmount = int32(victim->CountPctFromMaxHealth(uint32(healPct * pctFromDefense))); + victim->CastCustomSpell(victim, PAL_SPELL_ARDENT_DEFENDER_HEAL, &healAmount, NULL, NULL, true, NULL, aurEff); + victim->ToPlayer()->AddSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL, 0, time(NULL) + 120); + } + else if (remainingHealth < int32(allowedHealth)) + { + // Reduce damage that brings us under 35% (or full damage if we are already under 35%) by x% + uint32 damageToReduce = (victim->GetHealth() < allowedHealth) + ? dmgInfo.GetDamage() + : allowedHealth - remainingHealth; + absorbAmount = CalculatePctN(damageToReduce, absorbPct); + } + } + + void Register() + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_ardent_defender_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); + OnEffectAbsorb += AuraEffectAbsorbFn(spell_pal_ardent_defender_AuraScript::Absorb, EFFECT_0); + } }; - bool Load() + AuraScript* GetAuraScript() const { - healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); - absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); - return GetUnitOwner()->ToPlayer(); + return new spell_pal_ardent_defender_AuraScript(); } - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) - { - // Set absorbtion amount to unlimited - amount = -1; - } - - void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount) - { - Unit* victim = GetTarget(); - int32 remainingHealth = victim->GetHealth() - dmgInfo.GetDamage(); - uint32 allowedHealth = victim->CountPctFromMaxHealth(35); - // If damage kills us - if (remainingHealth <= 0 && !victim->ToPlayer()->HasSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL)) - { - // Cast healing spell, completely avoid damage - absorbAmount = dmgInfo.GetDamage(); - - uint32 defenseSkillValue = victim->GetDefenseSkillValue(); - // Max heal when defense skill denies critical hits from raid bosses - // Formula: max defense at level + 140 (raiting from gear) - uint32 reqDefForMaxHeal = victim->getLevel() * 5 + 140; - float pctFromDefense = (defenseSkillValue >= reqDefForMaxHeal) - ? 1.0f - : float(defenseSkillValue) / float(reqDefForMaxHeal); - - int32 healAmount = int32(victim->CountPctFromMaxHealth(uint32(healPct * pctFromDefense))); - victim->CastCustomSpell(victim, PAL_SPELL_ARDENT_DEFENDER_HEAL, &healAmount, NULL, NULL, true, NULL, aurEff); - victim->ToPlayer()->AddSpellCooldown(PAL_SPELL_ARDENT_DEFENDER_HEAL, 0, time(NULL) + 120); - } - else if (remainingHealth < int32(allowedHealth)) - { - // Reduce damage that brings us under 35% (or full damage if we are already under 35%) by x% - uint32 damageToReduce = (victim->GetHealth() < allowedHealth) - ? dmgInfo.GetDamage() - : allowedHealth - remainingHealth; - absorbAmount = CalculatePctN(damageToReduce, absorbPct); - } - } - - void Register() - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_pal_ardent_defender_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); - OnEffectAbsorb += AuraEffectAbsorbFn(spell_pal_ardent_defender_AuraScript::Absorb, EFFECT_0); - } - }; - - AuraScript* GetAuraScript() const - { - return new spell_pal_ardent_defender_AuraScript(); - } }; class spell_pal_blessing_of_faith : public SpellScriptLoader { -public: - spell_pal_blessing_of_faith() : SpellScriptLoader("spell_pal_blessing_of_faith") { } + public: + spell_pal_blessing_of_faith() : SpellScriptLoader("spell_pal_blessing_of_faith") { } - class spell_pal_blessing_of_faith_SpellScript : public SpellScript - { - PrepareSpellScript(spell_pal_blessing_of_faith_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_pal_blessing_of_faith_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_DRUID)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PALADIN)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PRIEST)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_SHAMAN)) - return false; - return true; - } + PrepareSpellScript(spell_pal_blessing_of_faith_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) - { - if (Unit* unitTarget = GetHitUnit()) + bool Validate(SpellInfo const* /*spellEntry*/) { - uint32 spell_id = 0; - switch (unitTarget->getClass()) - { - case CLASS_DRUID: spell_id = SPELL_BLESSING_OF_LOWER_CITY_DRUID; break; - case CLASS_PALADIN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PALADIN; break; - case CLASS_PRIEST: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PRIEST; break; - case CLASS_SHAMAN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_SHAMAN; break; - default: return; // ignore for non-healing classes - } - - GetCaster()->CastSpell(GetCaster(), spell_id, true); + if (!sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_DRUID) || !sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PALADIN) || !sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_PRIEST) || !sSpellMgr->GetSpellInfo(SPELL_BLESSING_OF_LOWER_CITY_SHAMAN)) + return false; + return true; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Unit* unitTarget = GetHitUnit()) + { + uint32 spell_id = 0; + switch (unitTarget->getClass()) + { + case CLASS_DRUID: spell_id = SPELL_BLESSING_OF_LOWER_CITY_DRUID; break; + case CLASS_PALADIN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PALADIN; break; + case CLASS_PRIEST: spell_id = SPELL_BLESSING_OF_LOWER_CITY_PRIEST; break; + case CLASS_SHAMAN: spell_id = SPELL_BLESSING_OF_LOWER_CITY_SHAMAN; break; + default: return; // ignore for non-healing classes + } + Unit* caster = GetCaster(); + caster->CastSpell(caster, spell_id, true); + } + } + + void Register() + { + // add dummy effect spell handler to Blessing of Faith + OnEffectHitTarget += SpellEffectFn(spell_pal_blessing_of_faith_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - // add dummy effect spell handler to Blessing of Faith - OnEffectHitTarget += SpellEffectFn(spell_pal_blessing_of_faith_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_pal_blessing_of_faith_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_pal_blessing_of_faith_SpellScript(); - } }; // 20911 Blessing of Sanctuary // 25899 Greater Blessing of Sanctuary class spell_pal_blessing_of_sanctuary : public SpellScriptLoader { -public: - spell_pal_blessing_of_sanctuary() : SpellScriptLoader("spell_pal_blessing_of_sanctuary") { } + public: + spell_pal_blessing_of_sanctuary() : SpellScriptLoader("spell_pal_blessing_of_sanctuary") { } - class spell_pal_blessing_of_sanctuary_AuraScript : public AuraScript - { - PrepareAuraScript(spell_pal_blessing_of_sanctuary_AuraScript) - bool Validate(SpellInfo const* /*entry*/) + class spell_pal_blessing_of_sanctuary_AuraScript : public AuraScript { - if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF)) - return false; - return true; - } + PrepareAuraScript(spell_pal_blessing_of_sanctuary_AuraScript); - void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + bool Validate(SpellInfo const* /*entry*/) + { + if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF)) + return false; + return true; + } + + void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); + if (Unit* caster = GetCaster()) + caster->CastSpell(target, PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, true); + } + + void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); + target->RemoveAura(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, GetCasterGUID()); + } + + void Register() + { + AfterEffectApply += AuraEffectApplyFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + AfterEffectRemove += AuraEffectRemoveFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + } + }; + + AuraScript* GetAuraScript() const { - Unit* target = GetTarget(); - if (Unit* pCaster = GetCaster()) - pCaster->CastSpell(target, PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, true); + return new spell_pal_blessing_of_sanctuary_AuraScript(); } - - void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { - Unit* target = GetTarget(); - target->RemoveAura(PALADIN_SPELL_BLESSING_OF_SANCTUARY_BUFF, GetCasterGUID()); - } - - void Register() - { - AfterEffectApply += AuraEffectApplyFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); - AfterEffectRemove += AuraEffectRemoveFn(spell_pal_blessing_of_sanctuary_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); - } - }; - - AuraScript* GetAuraScript() const - { - return new spell_pal_blessing_of_sanctuary_AuraScript(); - } }; // 63521 Guarded by The Light class spell_pal_guarded_by_the_light : public SpellScriptLoader { -public: - spell_pal_guarded_by_the_light() : SpellScriptLoader("spell_pal_guarded_by_the_light") { } + public: + spell_pal_guarded_by_the_light() : SpellScriptLoader("spell_pal_guarded_by_the_light") { } - class spell_pal_guarded_by_the_light_SpellScript : public SpellScript - { - PrepareSpellScript(spell_pal_guarded_by_the_light_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_pal_guarded_by_the_light_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_DIVINE_PLEA)) - return false; - return true; - } + PrepareSpellScript(spell_pal_guarded_by_the_light_SpellScript); - void HandleScriptEffect(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_DIVINE_PLEA)) + return false; + return true; + } + + void HandleScriptEffect(SpellEffIndex /*effIndex*/) + { + // Divine Plea + if (Aura* aura = GetCaster()->GetAura(PALADIN_SPELL_DIVINE_PLEA)) + aura->RefreshDuration(); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_pal_guarded_by_the_light_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } + }; + + SpellScript* GetSpellScript() const { - // Divine Plea - if (Aura* aura = GetCaster()->GetAura(PALADIN_SPELL_DIVINE_PLEA)) - aura->RefreshDuration(); + return new spell_pal_guarded_by_the_light_SpellScript(); } - - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_pal_guarded_by_the_light_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_pal_guarded_by_the_light_SpellScript(); - } }; class spell_pal_holy_shock : public SpellScriptLoader { -public: - spell_pal_holy_shock() : SpellScriptLoader("spell_pal_holy_shock") { } + public: + spell_pal_holy_shock() : SpellScriptLoader("spell_pal_holy_shock") { } - class spell_pal_holy_shock_SpellScript : public SpellScript - { - PrepareSpellScript(spell_pal_holy_shock_SpellScript) - bool Validate(SpellInfo const* spellEntry) + class spell_pal_holy_shock_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_HOLY_SHOCK_R1)) - return false; + PrepareSpellScript(spell_pal_holy_shock_SpellScript) + bool Validate(SpellInfo const* spellEntry) + { + if (!sSpellMgr->GetSpellInfo(PALADIN_SPELL_HOLY_SHOCK_R1)) + return false; - // can't use other spell than holy shock due to spell_ranks dependency - if (sSpellMgr->GetFirstSpellInChain(PALADIN_SPELL_HOLY_SHOCK_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id)) - return false; + // can't use other spell than holy shock due to spell_ranks dependency + if (sSpellMgr->GetFirstSpellInChain(PALADIN_SPELL_HOLY_SHOCK_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id)) + return false; - uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id); - if (!sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank, true)) - return false; - if (!sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank, true)) - return false; + uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id); + if (!sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank, true) || !sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank, true)) + return false; - return true; - } + return true; + } - void HandleDummy(SpellEffIndex /*effIndex*/) - { - if (Unit* unitTarget = GetHitUnit()) + void HandleDummy(SpellEffIndex /*effIndex*/) { Unit* caster = GetCaster(); - - uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); - - if (caster->IsFriendlyTo(unitTarget)) - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank), true, 0); - else - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank), true, 0); + if (Unit* unitTarget = GetHitUnit()) + { + uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); + if (caster->IsFriendlyTo(unitTarget)) + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_HEALING, rank), true, 0); + else + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PALADIN_SPELL_HOLY_SHOCK_R1_DAMAGE, rank), true, 0); + } } - } - void Register() + void Register() + { + // add dummy effect spell handler to Holy Shock + OnEffectHitTarget += SpellEffectFn(spell_pal_holy_shock_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - // add dummy effect spell handler to Holy Shock - OnEffectHitTarget += SpellEffectFn(spell_pal_holy_shock_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_pal_holy_shock_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_pal_holy_shock_SpellScript(); - } }; class spell_pal_judgement_of_command : public SpellScriptLoader { -public: - spell_pal_judgement_of_command() : SpellScriptLoader("spell_pal_judgement_of_command") { } + public: + spell_pal_judgement_of_command() : SpellScriptLoader("spell_pal_judgement_of_command") { } - class spell_pal_judgement_of_command_SpellScript : public SpellScript - { - PrepareSpellScript(spell_pal_judgement_of_command_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_pal_judgement_of_command_SpellScript : public SpellScript { - if (Unit* unitTarget = GetHitUnit()) - if (SpellInfo const* spell_proto = sSpellMgr->GetSpellInfo(GetEffectValue())) - GetCaster()->CastSpell(unitTarget, spell_proto, true, NULL); - } + PrepareSpellScript(spell_pal_judgement_of_command_SpellScript) + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Unit* unitTarget = GetHitUnit()) + if (SpellInfo const* spell_proto = sSpellMgr->GetSpellInfo(GetEffectValue())) + GetCaster()->CastSpell(unitTarget, spell_proto, true, NULL); + } - void Register() + void Register() + { + // add dummy effect spell handler to Judgement of Command + OnEffectHitTarget += SpellEffectFn(spell_pal_judgement_of_command_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - // add dummy effect spell handler to Judgement of Command - OnEffectHitTarget += SpellEffectFn(spell_pal_judgement_of_command_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_pal_judgement_of_command_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_pal_judgement_of_command_SpellScript(); - } }; class spell_pal_divine_storm : public SpellScriptLoader { -public: - spell_pal_divine_storm() : SpellScriptLoader("spell_pal_divine_storm") { } + public: + spell_pal_divine_storm() : SpellScriptLoader("spell_pal_divine_storm") { } - class spell_pal_divine_storm_SpellScript : public SpellScript - { - PrepareSpellScript(spell_pal_divine_storm_SpellScript); - - uint32 healPct; - - bool Load() + class spell_pal_divine_storm_SpellScript : public SpellScript { - healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(GetCaster()); - return true; - } + PrepareSpellScript(spell_pal_divine_storm_SpellScript); - void TriggerHeal() + uint32 healPct; + + bool Validate(SpellInfo const* /* spell */) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DIVINE_STORM_DUMMY)) + return false; + return true; + } + + bool Load() + { + healPct = GetSpellInfo()->Effects[EFFECT_1].CalcValue(GetCaster()); + return true; + } + + void TriggerHeal() + { + Unit* caster = GetCaster(); + caster->CastCustomSpell(SPELL_DIVINE_STORM_DUMMY, SPELLVALUE_BASE_POINT0, (GetHitDamage() * healPct) / 100, caster, true); + } + + void Register() + { + AfterHit += SpellHitFn(spell_pal_divine_storm_SpellScript::TriggerHeal); + } + }; + + SpellScript* GetSpellScript() const { - GetCaster()->CastCustomSpell(SPELL_DIVINE_STORM_DUMMY, SPELLVALUE_BASE_POINT0, (GetHitDamage() * healPct) / 100, GetCaster(), true); + return new spell_pal_divine_storm_SpellScript(); } +}; - void Register() +class spell_pal_divine_storm_dummy : public SpellScriptLoader +{ + public: + spell_pal_divine_storm_dummy() : SpellScriptLoader("spell_pal_divine_storm_dummy") { } + + class spell_pal_divine_storm_dummy_SpellScript : public SpellScript { - AfterHit += SpellHitFn(spell_pal_divine_storm_SpellScript::TriggerHeal); - } - }; + PrepareSpellScript(spell_pal_divine_storm_dummy_SpellScript); - SpellScript* GetSpellScript() const - { - return new spell_pal_divine_storm_SpellScript(); - } + bool Validate(SpellInfo const* /* spell */) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DIVINE_STORM_HEAL)) + return false; + return true; + } + + void CountTargets(std::list& targetList) + { + _targetCount = targetList.size(); + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (!_targetCount || ! GetHitUnit()) + return; + + int32 heal = GetEffectValue() / _targetCount; + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_DIVINE_STORM_HEAL, &heal, NULL, NULL, true); + } + private: + uint32 _targetCount; + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_pal_divine_storm_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + OnUnitTargetSelect += SpellUnitTargetFn(spell_pal_divine_storm_dummy_SpellScript::CountTargets, EFFECT_0, TARGET_UNIT_CASTER_AREA_RAID); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_pal_divine_storm_dummy_SpellScript(); + } }; void AddSC_paladin_spell_scripts() @@ -374,4 +422,5 @@ void AddSC_paladin_spell_scripts() new spell_pal_holy_shock(); new spell_pal_judgement_of_command(); new spell_pal_divine_storm(); + new spell_pal_divine_storm_dummy(); } diff --git a/src/server/scripts/Spells/spell_priest.cpp b/src/server/scripts/Spells/spell_priest.cpp index ee5f6a6d7..70027ca9f 100644 --- a/src/server/scripts/Spells/spell_priest.cpp +++ b/src/server/scripts/Spells/spell_priest.cpp @@ -21,7 +21,8 @@ * Scriptnames of files in this file should be prefixed with "spell_pri_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" #include "GridNotifiers.h" @@ -49,7 +50,9 @@ class spell_pri_guardian_spirit : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - return sSpellMgr->GetSpellInfo(PRIEST_SPELL_GUARDIAN_SPIRIT_HEAL) != NULL; + if (!sSpellMgr->GetSpellInfo(PRIEST_SPELL_GUARDIAN_SPIRIT_HEAL)) + return false; + return true; } bool Load() @@ -101,11 +104,8 @@ class spell_pri_mana_burn : public SpellScriptLoader void HandleAfterHit() { - Unit* unitTarget = GetHitUnit(); - if (!unitTarget) - return; - - unitTarget->RemoveAurasWithMechanic((1 << MECHANIC_FEAR) | (1 << MECHANIC_POLYMORPH)); + if (Unit* unitTarget = GetHitUnit()) + unitTarget->RemoveAurasWithMechanic((1 << MECHANIC_FEAR) | (1 << MECHANIC_POLYMORPH)); } void Register() @@ -204,18 +204,19 @@ class spell_pri_penance : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { - Unit* unitTarget = GetHitUnit(); - if (!unitTarget || !unitTarget->isAlive()) - return; - Unit* caster = GetCaster(); + if (Unit* unitTarget = GetHitUnit()) + { + if(!unitTarget->isAlive()) + return; - uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); + uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); - if (caster->IsFriendlyTo(unitTarget)) - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PRIEST_SPELL_PENANCE_R1_HEAL, rank), false, 0); - else - caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PRIEST_SPELL_PENANCE_R1_DAMAGE, rank), false, 0); + if (caster->IsFriendlyTo(unitTarget)) + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PRIEST_SPELL_PENANCE_R1_HEAL, rank), false, 0); + else + caster->CastSpell(unitTarget, sSpellMgr->GetSpellWithRank(PRIEST_SPELL_PENANCE_R1_DAMAGE, rank), false, 0); + } } void Register() @@ -243,7 +244,9 @@ class spell_pri_reflective_shield_trigger : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - return sSpellMgr->GetSpellInfo(PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED) && sSpellMgr->GetSpellInfo(PRIEST_SPELL_REFLECTIVE_SHIELD_R1); + if (!sSpellMgr->GetSpellInfo(PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED) || !sSpellMgr->GetSpellInfo(PRIEST_SPELL_REFLECTIVE_SHIELD_R1)) + return false; + return true; } void Trigger(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount) @@ -251,14 +254,13 @@ class spell_pri_reflective_shield_trigger : public SpellScriptLoader Unit* target = GetTarget(); if (dmgInfo.GetAttacker() == target) return; - Unit* caster = GetCaster(); - if (!caster) - return; - if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(PRIEST_SPELL_REFLECTIVE_SHIELD_R1, EFFECT_0)) - { - int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount()); - target->CastCustomSpell(dmgInfo.GetAttacker(), PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); - } + + if (Unit* caster = GetCaster()) + if (AuraEffect* talentAurEff = target->GetAuraEffectOfRankedSpell(PRIEST_SPELL_REFLECTIVE_SHIELD_R1, EFFECT_0)) + { + int32 bp = CalculatePctN(absorbAmount, talentAurEff->GetAmount()); + target->CastCustomSpell(dmgInfo.GetAttacker(), PRIEST_SPELL_REFLECTIVE_SHIELD_TRIGGERED, &bp, NULL, NULL, true, NULL, aurEff); + } } void Register() diff --git a/src/server/scripts/Spells/spell_quest.cpp b/src/server/scripts/Spells/spell_quest.cpp index 940e494f1..6de1ffa83 100644 --- a/src/server/scripts/Spells/spell_quest.cpp +++ b/src/server/scripts/Spells/spell_quest.cpp @@ -21,48 +21,50 @@ * Scriptnames of files in this file should be prefixed with "spell_q#questID_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "ScriptedCreature.h" +#include "SpellScript.h" #include "Vehicle.h" class spell_generic_quest_update_entry_SpellScript : public SpellScript { - PrepareSpellScript(spell_generic_quest_update_entry_SpellScript) -private: - uint16 _spellEffect; - uint8 _effIndex; - uint32 _originalEntry; - uint32 _newEntry; - bool _shouldAttack; - uint32 _despawnTime; + PrepareSpellScript(spell_generic_quest_update_entry_SpellScript); + private: + uint16 _spellEffect; + uint8 _effIndex; + uint32 _originalEntry; + uint32 _newEntry; + bool _shouldAttack; + uint32 _despawnTime; -public: - spell_generic_quest_update_entry_SpellScript(uint16 spellEffect, uint8 effIndex, uint32 originalEntry, uint32 newEntry, bool shouldAttack, uint32 despawnTime = 0) : - SpellScript(), _spellEffect(spellEffect), _effIndex(effIndex), _originalEntry(originalEntry), - _newEntry(newEntry), _shouldAttack(shouldAttack), _despawnTime(despawnTime) { } + public: + spell_generic_quest_update_entry_SpellScript(uint16 spellEffect, uint8 effIndex, uint32 originalEntry, uint32 newEntry, bool shouldAttack, uint32 despawnTime = 0) : + SpellScript(), _spellEffect(spellEffect), _effIndex(effIndex), _originalEntry(originalEntry), + _newEntry(newEntry), _shouldAttack(shouldAttack), _despawnTime(despawnTime) { } - void HandleDummy(SpellEffIndex /*effIndex*/) - { - if (Creature* creatureTarget = GetHitCreature()) - if (!creatureTarget->isPet() && creatureTarget->GetEntry() == _originalEntry) - { - creatureTarget->UpdateEntry(_newEntry); - if (_shouldAttack && creatureTarget->IsAIEnabled) - creatureTarget->AI()->AttackStart(GetCaster()); + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Creature* creatureTarget = GetHitCreature()) + if (!creatureTarget->isPet() && creatureTarget->GetEntry() == _originalEntry) + { + creatureTarget->UpdateEntry(_newEntry); + if (_shouldAttack && creatureTarget->IsAIEnabled) + creatureTarget->AI()->AttackStart(GetCaster()); - if (_despawnTime) - creatureTarget->DespawnOrUnsummon(_despawnTime); - } - } + if (_despawnTime) + creatureTarget->DespawnOrUnsummon(_despawnTime); + } + } - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_generic_quest_update_entry_SpellScript::HandleDummy, _effIndex, _spellEffect); - } + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_generic_quest_update_entry_SpellScript::HandleDummy, _effIndex, _spellEffect); + } }; // http://www.wowhead.com/quest=55 Morbent Fel // 8913 Sacred Cleansing -enum eQuest55Data +enum Quest55Data { NPC_MORBENT = 1200, NPC_WEAKENED_MORBENT = 24782, @@ -70,18 +72,18 @@ enum eQuest55Data class spell_q55_sacred_cleansing : public SpellScriptLoader { -public: - spell_q55_sacred_cleansing() : SpellScriptLoader("spell_q55_sacred_cleansing") { } + public: + spell_q55_sacred_cleansing() : SpellScriptLoader("spell_q55_sacred_cleansing") { } - SpellScript* GetSpellScript() const - { - return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_1, NPC_MORBENT, NPC_WEAKENED_MORBENT, true); - } + SpellScript* GetSpellScript() const + { + return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_1, NPC_MORBENT, NPC_WEAKENED_MORBENT, true); + } }; // http://www.wowhead.com/quest=5206 Marauders of Darrowshire // 17271 Test Fetid Skull -enum eQuest5206Data +enum Quest5206Data { SPELL_CREATE_RESONATING_SKULL = 17269, SPELL_CREATE_BONE_DUST = 17270 @@ -89,47 +91,48 @@ enum eQuest5206Data class spell_q5206_test_fetid_skull : public SpellScriptLoader { -public: - spell_q5206_test_fetid_skull() : SpellScriptLoader("spell_q5206_test_fetid_skull") { } + public: + spell_q5206_test_fetid_skull() : SpellScriptLoader("spell_q5206_test_fetid_skull") { } - class spell_q5206_test_fetid_skull_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q5206_test_fetid_skull_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q5206_test_fetid_skull_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_CREATE_RESONATING_SKULL)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_CREATE_BONE_DUST)) - return false; - return true; - } + PrepareSpellScript(spell_q5206_test_fetid_skull_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() == TYPEID_PLAYER) + bool Load() { - uint32 spellId = roll_chance_i(50) ? SPELL_CREATE_RESONATING_SKULL : SPELL_CREATE_BONE_DUST; - pCaster->CastSpell(pCaster, spellId, true, NULL); + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - } - void Register() + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_CREATE_RESONATING_SKULL) || !sSpellMgr->GetSpellInfo(SPELL_CREATE_BONE_DUST)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + uint32 spellId = roll_chance_i(50) ? SPELL_CREATE_RESONATING_SKULL : SPELL_CREATE_BONE_DUST; + caster->CastSpell(caster, spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_q5206_test_fetid_skull_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_q5206_test_fetid_skull_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q5206_test_fetid_skull_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q5206_test_fetid_skull_SpellScript(); - } }; // http://www.wowhead.com/quest=6124 Curing the Sick (A) // http://www.wowhead.com/quest=6129 Curing the Sick (H) // 19512 Apply Salve -enum eQuests6124_6129Data +enum Quests6124_6129Data { NPC_SICKLY_GAZELLE = 12296, NPC_CURED_GAZELLE = 12297, @@ -140,20 +143,26 @@ enum eQuests6124_6129Data class spell_q6124_6129_apply_salve : public SpellScriptLoader { -public: - spell_q6124_6129_apply_salve() : SpellScriptLoader("spell_q6124_6129_apply_salve") { } + public: + spell_q6124_6129_apply_salve() : SpellScriptLoader("spell_q6124_6129_apply_salve") { } - class spell_q6124_6129_apply_salve_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q6124_6129_apply_salve_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_q6124_6129_apply_salve_SpellScript : public SpellScript { - if (GetCastItem()) - if (Player* pCaster = GetCaster()->ToPlayer()) + PrepareSpellScript(spell_q6124_6129_apply_salve_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + if (GetCastItem()) if (Creature* creatureTarget = GetHitCreature()) { uint32 uiNewEntry = 0; - switch (pCaster->GetTeam()) + switch (caster->GetTeam()) { case HORDE: if (creatureTarget->GetEntry() == NPC_SICKLY_GAZELLE) @@ -170,23 +179,23 @@ public: creatureTarget->DespawnOrUnsummon(DESPAWN_TIME); } } - } + } - void Register() + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q6124_6129_apply_salve_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q6124_6129_apply_salve_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q6124_6129_apply_salve_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q6124_6129_apply_salve_SpellScript(); - } }; // http://www.wowhead.com/quest=10255 Testing the Antidote // 34665 Administer Antidote -enum eQuest10255Data +enum Quest10255Data { NPC_HELBOAR = 16880, NPC_DREADTUSK = 16992, @@ -194,18 +203,18 @@ enum eQuest10255Data class spell_q10255_administer_antidote : public SpellScriptLoader { -public: - spell_q10255_administer_antidote() : SpellScriptLoader("spell_q10255_administer_antidote") { } + public: + spell_q10255_administer_antidote() : SpellScriptLoader("spell_q10255_administer_antidote") { } - SpellScript* GetSpellScript() const - { - return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_0, NPC_HELBOAR, NPC_DREADTUSK, true); - } + SpellScript* GetSpellScript() const + { + return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_0, NPC_HELBOAR, NPC_DREADTUSK, true); + } }; // http://www.wowhead.com/quest=11396 Bring Down Those Shields (A) // http://www.wowhead.com/quest=11399 Bring Down Those Shields (H) -enum eQuest11396_11399Data +enum Quest11396_11399Data { SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3 = 43874, SPELL_SCOURGING_CRYSTAL_CONTROLLER = 43878 @@ -214,115 +223,116 @@ enum eQuest11396_11399Data // 43874 Scourge Mur'gul Camp: Force Shield Arcane Purple x3 class spell_q11396_11399_force_shield_arcane_purple_x3 : public SpellScriptLoader { -public: - spell_q11396_11399_force_shield_arcane_purple_x3() : SpellScriptLoader("spell_q11396_11399_force_shield_arcane_purple_x3") { } + public: + spell_q11396_11399_force_shield_arcane_purple_x3() : SpellScriptLoader("spell_q11396_11399_force_shield_arcane_purple_x3") { } - class spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript : public AuraScript - { - PrepareAuraScript(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript) - void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + class spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript : public AuraScript { - Unit* target = GetTarget(); + PrepareAuraScript(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript); + + void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { + Unit* target = GetTarget(); target->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC); target->AddUnitState(UNIT_STATE_ROOT); - } + } - void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) - { + void HandleEffectRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + { GetTarget()->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_PC); - } + } - void Register() + void Register() + { + OnEffectApply += AuraEffectApplyFn(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + OnEffectRemove += AuraEffectRemoveFn(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + } + + }; + + AuraScript* GetAuraScript() const { - OnEffectApply += AuraEffectApplyFn(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); - OnEffectRemove += AuraEffectRemoveFn(spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript::HandleEffectRemove, EFFECT_0, SPELL_AURA_DUMMY, AURA_EFFECT_HANDLE_REAL); + return new spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript(); } - - }; - - AuraScript* GetAuraScript() const - { - return new spell_q11396_11399_force_shield_arcane_purple_x3_AuraScript(); - } }; // 50133 Scourging Crystal Controller class spell_q11396_11399_scourging_crystal_controller : public SpellScriptLoader { -public: - spell_q11396_11399_scourging_crystal_controller() : SpellScriptLoader("spell_q11396_11399_scourging_crystal_controller") { } + public: + spell_q11396_11399_scourging_crystal_controller() : SpellScriptLoader("spell_q11396_11399_scourging_crystal_controller") { } - class spell_q11396_11399_scourging_crystal_controller_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q11396_11399_scourging_crystal_controller_SpellScript); - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q11396_11399_scourging_crystal_controller_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SCOURGING_CRYSTAL_CONTROLLER)) - return false; - return true; - } + PrepareSpellScript(spell_q11396_11399_scourging_crystal_controller_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3) || !sSpellMgr->GetSpellInfo(SPELL_SCOURGING_CRYSTAL_CONTROLLER)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Unit* target = GetTargetUnit()) + if (target->GetTypeId() == TYPEID_UNIT && target->HasAura(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3)) + // Make sure nobody else is channeling the same target + if (!target->HasAura(SPELL_SCOURGING_CRYSTAL_CONTROLLER)) + GetCaster()->CastSpell(target, SPELL_SCOURGING_CRYSTAL_CONTROLLER, true, GetCastItem()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q11396_11399_scourging_crystal_controller_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - if (Unit* target = GetTargetUnit()) - if (target->GetTypeId() == TYPEID_UNIT && target->HasAura(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3)) - // Make sure nobody else is channeling the same target - if (!target->HasAura(SPELL_SCOURGING_CRYSTAL_CONTROLLER)) - GetCaster()->CastSpell(target, SPELL_SCOURGING_CRYSTAL_CONTROLLER, true, GetCastItem()); - } - - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_q11396_11399_scourging_crystal_controller_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q11396_11399_scourging_crystal_controller_SpellScript(); - }; + return new spell_q11396_11399_scourging_crystal_controller_SpellScript(); + }; }; // 43882 Scourging Crystal Controller Dummy class spell_q11396_11399_scourging_crystal_controller_dummy : public SpellScriptLoader { -public: - spell_q11396_11399_scourging_crystal_controller_dummy() : SpellScriptLoader("spell_q11396_11399_scourging_crystal_controller_dummy") { } + public: + spell_q11396_11399_scourging_crystal_controller_dummy() : SpellScriptLoader("spell_q11396_11399_scourging_crystal_controller_dummy") { } - class spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript); - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3)) - return false; - return true; - } + PrepareSpellScript(spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + if (Unit* target = GetHitUnit()) + if (target->GetTypeId() == TYPEID_UNIT) + target->RemoveAurasDueToSpell(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - if (Unit* target = GetTargetUnit()) - if (target->GetTypeId() == TYPEID_UNIT) - target->RemoveAurasDueToSpell(SPELL_FORCE_SHIELD_ARCANE_PURPLE_X3); - } - - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript(); - }; + return new spell_q11396_11399_scourging_crystal_controller_dummy_SpellScript(); + }; }; // http://www.wowhead.com/quest=11515 Blood for Blood // 44936 Quest - Fel Siphon Dummy -enum eQuest11515Data +enum Quest11515Data { NPC_FELBLOOD_INITIATE = 24918, NPC_EMACIATED_FELBLOOD = 24955 @@ -330,18 +340,18 @@ enum eQuest11515Data class spell_q11515_fel_siphon_dummy : public SpellScriptLoader { -public: - spell_q11515_fel_siphon_dummy() : SpellScriptLoader("spell_q11515_fel_siphon_dummy") { } + public: + spell_q11515_fel_siphon_dummy() : SpellScriptLoader("spell_q11515_fel_siphon_dummy") { } - SpellScript* GetSpellScript() const - { - return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_0, NPC_FELBLOOD_INITIATE, NPC_EMACIATED_FELBLOOD, true); - } + SpellScript* GetSpellScript() const + { + return new spell_generic_quest_update_entry_SpellScript(SPELL_EFFECT_DUMMY, EFFECT_0, NPC_FELBLOOD_INITIATE, NPC_EMACIATED_FELBLOOD, true); + } }; // http://www.wowhead.com/quest=11587 Prison Break // 45449 Arcane Prisoner Rescue -enum eQuest11587Data +enum Quest11587Data { SPELL_SUMMON_ARCANE_PRISONER_MALE = 45446, // Summon Arcane Prisoner - Male SPELL_SUMMON_ARCANE_PRISONER_FEMALE = 45448, // Summon Arcane Prisoner - Female @@ -350,51 +360,48 @@ enum eQuest11587Data class spell_q11587_arcane_prisoner_rescue : public SpellScriptLoader { -public: - spell_q11587_arcane_prisoner_rescue() : SpellScriptLoader("spell_q11587_arcane_prisoner_rescue") { } + public: + spell_q11587_arcane_prisoner_rescue() : SpellScriptLoader("spell_q11587_arcane_prisoner_rescue") { } - class spell_q11587_arcane_prisoner_rescue_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q11587_arcane_prisoner_rescue_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q11587_arcane_prisoner_rescue_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ARCANE_PRISONER_MALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ARCANE_PRISONER_FEMALE)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_ARCANE_PRISONER_KILL_CREDIT)) - return false; - return true; - } + PrepareSpellScript(spell_q11587_arcane_prisoner_rescue_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Unit* caster = GetCaster(); - if (Unit* unitTarget = GetHitUnit()) + bool Validate(SpellInfo const* /*spellEntry*/) { - uint32 spellId = SPELL_SUMMON_ARCANE_PRISONER_MALE; - if (rand() % 2) - spellId = SPELL_SUMMON_ARCANE_PRISONER_FEMALE; - caster->CastSpell(caster, spellId, true); - unitTarget->CastSpell(caster, SPELL_ARCANE_PRISONER_KILL_CREDIT, true); + if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ARCANE_PRISONER_MALE) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_ARCANE_PRISONER_FEMALE) || !sSpellMgr->GetSpellInfo(SPELL_ARCANE_PRISONER_KILL_CREDIT)) + return false; + return true; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* unitTarget = GetHitUnit()) + { + uint32 spellId = SPELL_SUMMON_ARCANE_PRISONER_MALE; + if (rand() % 2) + spellId = SPELL_SUMMON_ARCANE_PRISONER_FEMALE; + caster->CastSpell(caster, spellId, true); + unitTarget->CastSpell(caster, SPELL_ARCANE_PRISONER_KILL_CREDIT, true); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q11587_arcane_prisoner_rescue_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q11587_arcane_prisoner_rescue_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q11587_arcane_prisoner_rescue_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q11587_arcane_prisoner_rescue_SpellScript(); - } }; // http://www.wowhead.com/quest=11730 Master and Servant // 46023 The Ultrasonic Screwdriver -enum eQuest11730Data +enum Quest11730Data { SPELL_SUMMON_SCAVENGEBOT_004A8 = 46063, SPELL_SUMMON_SENTRYBOT_57K = 46068, @@ -411,74 +418,63 @@ enum eQuest11730Data class spell_q11730_ultrasonic_screwdriver : public SpellScriptLoader { -public: - spell_q11730_ultrasonic_screwdriver() : SpellScriptLoader("spell_q11730_ultrasonic_screwdriver") { } + public: + spell_q11730_ultrasonic_screwdriver() : SpellScriptLoader("spell_q11730_ultrasonic_screwdriver") { } - class spell_q11730_ultrasonic_screwdriver_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q11730_ultrasonic_screwdriver_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q11730_ultrasonic_screwdriver_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_SCAVENGEBOT_004A8)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_SENTRYBOT_57K)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_DEFENDOTANK_66D)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_SCAVENGEBOT_005B6)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_55D_COLLECTATRON)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_ROBOT_KILL_CREDIT)) - return false; - return true; - } + PrepareSpellScript(spell_q11730_ultrasonic_screwdriver_SpellScript); - void HandleDummy(SpellEffIndex /*effIndex*/) - { - Item* castItem = GetCastItem(); - if (!castItem) - return; - - Unit* pCaster = GetCaster(); - if (pCaster->GetTypeId() != TYPEID_PLAYER) - return; - - Creature* target = GetHitCreature(); - if (!target) - return; - - uint32 spellId = 0; - switch (target->GetEntry()) + bool Load() { - case NPC_SCAVENGEBOT_004A8: spellId = SPELL_SUMMON_SCAVENGEBOT_004A8; break; - case NPC_SENTRYBOT_57K: spellId = SPELL_SUMMON_SENTRYBOT_57K; break; - case NPC_DEFENDOTANK_66D: spellId = SPELL_SUMMON_DEFENDOTANK_66D; break; - case NPC_SCAVENGEBOT_005B6: spellId = SPELL_SUMMON_SCAVENGEBOT_005B6; break; - case NPC_55D_COLLECTATRON: spellId = SPELL_SUMMON_55D_COLLECTATRON; break; - default: - return; + return GetCaster()->GetTypeId() == TYPEID_PLAYER && GetCastItem(); } - pCaster->CastSpell(pCaster, spellId, true, castItem); - pCaster->CastSpell(pCaster, SPELL_ROBOT_KILL_CREDIT, true); - target->DespawnOrUnsummon(); - } - void Register() + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_SCAVENGEBOT_004A8) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_SENTRYBOT_57K) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_DEFENDOTANK_66D) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_SCAVENGEBOT_005B6) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_55D_COLLECTATRON) || !sSpellMgr->GetSpellInfo(SPELL_ROBOT_KILL_CREDIT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Item* castItem = GetCastItem(); + Unit* caster = GetCaster(); + if (Creature* target = GetHitCreature()) + { + uint32 spellId = 0; + switch (target->GetEntry()) + { + case NPC_SCAVENGEBOT_004A8: spellId = SPELL_SUMMON_SCAVENGEBOT_004A8; break; + case NPC_SENTRYBOT_57K: spellId = SPELL_SUMMON_SENTRYBOT_57K; break; + case NPC_DEFENDOTANK_66D: spellId = SPELL_SUMMON_DEFENDOTANK_66D; break; + case NPC_SCAVENGEBOT_005B6: spellId = SPELL_SUMMON_SCAVENGEBOT_005B6; break; + case NPC_55D_COLLECTATRON: spellId = SPELL_SUMMON_55D_COLLECTATRON; break; + default: + return; + } + caster->CastSpell(caster, spellId, true, castItem); + caster->CastSpell(caster, SPELL_ROBOT_KILL_CREDIT, true); + target->DespawnOrUnsummon(); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q11730_ultrasonic_screwdriver_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q11730_ultrasonic_screwdriver_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q11730_ultrasonic_screwdriver_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q11730_ultrasonic_screwdriver_SpellScript(); - } }; // http://www.wowhead.com/quest=12459 That Which Creates Can Also Destroy // 49587 Seeds of Nature's Wrath -enum eQuest12459Data +enum Quest12459Data { NPC_REANIMATED_FROSTWYRM = 26841, NPC_WEAK_REANIMATED_FROSTWYRM = 27821, @@ -492,44 +488,44 @@ enum eQuest12459Data class spell_q12459_seeds_of_natures_wrath : public SpellScriptLoader { -public: - spell_q12459_seeds_of_natures_wrath() : SpellScriptLoader("spell_q12459_seeds_of_natures_wrath") { } - - class spell_q12459_seeds_of_natures_wrath_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_q12459_seeds_of_natures_wrath_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + spell_q12459_seeds_of_natures_wrath() : SpellScriptLoader("spell_q12459_seeds_of_natures_wrath") { } + + class spell_q12459_seeds_of_natures_wrath_SpellScript : public SpellScript { - if (Creature* creatureTarget = GetHitCreature()) + PrepareSpellScript(spell_q12459_seeds_of_natures_wrath_SpellScript); + + void HandleDummy(SpellEffIndex /*effIndex*/) { - uint32 uiNewEntry = 0; - switch (creatureTarget->GetEntry()) + if (Creature* creatureTarget = GetHitCreature()) { - case NPC_REANIMATED_FROSTWYRM: uiNewEntry = NPC_WEAK_REANIMATED_FROSTWYRM; break; - case NPC_TURGID: uiNewEntry = NPC_WEAK_TURGID; break; - case NPC_DEATHGAZE: uiNewEntry = NPC_WEAK_DEATHGAZE; break; + uint32 uiNewEntry = 0; + switch (creatureTarget->GetEntry()) + { + case NPC_REANIMATED_FROSTWYRM: uiNewEntry = NPC_WEAK_REANIMATED_FROSTWYRM; break; + case NPC_TURGID: uiNewEntry = NPC_WEAK_TURGID; break; + case NPC_DEATHGAZE: uiNewEntry = NPC_WEAK_DEATHGAZE; break; + } + if (uiNewEntry) + creatureTarget->UpdateEntry(uiNewEntry); } - if (uiNewEntry) - creatureTarget->UpdateEntry(uiNewEntry); } - } - void Register() + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q12459_seeds_of_natures_wrath_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q12459_seeds_of_natures_wrath_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q12459_seeds_of_natures_wrath_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q12459_seeds_of_natures_wrath_SpellScript(); - } }; // http://www.wowhead.com/quest=12634 Some Make Lemonade, Some Make Liquor // 51840 Despawn Fruit Tosser -enum eQuest12634Data +enum Quest12634Data { SPELL_BANANAS_FALL_TO_GROUND = 51836, SPELL_ORANGE_FALLS_TO_GROUND = 51837, @@ -539,90 +535,84 @@ enum eQuest12634Data class spell_q12634_despawn_fruit_tosser : public SpellScriptLoader { -public: - spell_q12634_despawn_fruit_tosser() : SpellScriptLoader("spell_q12634_despawn_fruit_tosser") { } - - class spell_q12634_despawn_fruit_tosser_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_q12634_despawn_fruit_tosser_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_BANANAS_FALL_TO_GROUND)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_ORANGE_FALLS_TO_GROUND)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_PAPAYA_FALLS_TO_GROUND)) - return false; - if (!sSpellMgr->GetSpellInfo(SPELL_SUMMON_ADVENTUROUS_DWARF)) - return false; - return true; - } + spell_q12634_despawn_fruit_tosser() : SpellScriptLoader("spell_q12634_despawn_fruit_tosser") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_q12634_despawn_fruit_tosser_SpellScript : public SpellScript { - uint32 spellId = SPELL_BANANAS_FALL_TO_GROUND; - switch (urand(0, 3)) + PrepareSpellScript(spell_q12634_despawn_fruit_tosser_SpellScript); + + bool Validate(SpellInfo const* /*spellEntry*/) { - case 1: spellId = SPELL_ORANGE_FALLS_TO_GROUND; break; - case 2: spellId = SPELL_PAPAYA_FALLS_TO_GROUND; break; + if (!sSpellMgr->GetSpellInfo(SPELL_BANANAS_FALL_TO_GROUND) || !sSpellMgr->GetSpellInfo(SPELL_ORANGE_FALLS_TO_GROUND) || !sSpellMgr->GetSpellInfo(SPELL_PAPAYA_FALLS_TO_GROUND) || !sSpellMgr->GetSpellInfo(SPELL_SUMMON_ADVENTUROUS_DWARF)) + return false; + return true; } - // sometimes, if you're lucky, you get a dwarf - if (roll_chance_i(5)) - spellId = SPELL_SUMMON_ADVENTUROUS_DWARF; - GetCaster()->CastSpell(GetCaster(), spellId, true, NULL); - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + uint32 spellId = SPELL_BANANAS_FALL_TO_GROUND; + switch (urand(0, 3)) + { + case 1: spellId = SPELL_ORANGE_FALLS_TO_GROUND; break; + case 2: spellId = SPELL_PAPAYA_FALLS_TO_GROUND; break; + } + // sometimes, if you're lucky, you get a dwarf + if (roll_chance_i(5)) + spellId = SPELL_SUMMON_ADVENTUROUS_DWARF; + GetCaster()->CastSpell(GetCaster(), spellId, true, NULL); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_q12634_despawn_fruit_tosser_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_q12634_despawn_fruit_tosser_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q12634_despawn_fruit_tosser_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q12634_despawn_fruit_tosser_SpellScript(); - } }; // http://www.wowhead.com/quest=12683 Burning to Help // 52308 Take Sputum Sample class spell_q12683_take_sputum_sample : public SpellScriptLoader { -public: - spell_q12683_take_sputum_sample() : SpellScriptLoader("spell_q12683_take_sputum_sample") { } - - class spell_q12683_take_sputum_sample_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_q12683_take_sputum_sample_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) - { - uint32 reqAuraId = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + spell_q12683_take_sputum_sample() : SpellScriptLoader("spell_q12683_take_sputum_sample") { } - Unit* pCaster = GetCaster(); - if (pCaster->HasAuraEffect(reqAuraId, 0)) + class spell_q12683_take_sputum_sample_SpellScript : public SpellScript + { + PrepareSpellScript(spell_q12683_take_sputum_sample_SpellScript); + + void HandleDummy(SpellEffIndex /*effIndex*/) { - uint32 spellId = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); - pCaster->CastSpell(pCaster, spellId, true, NULL); + uint32 reqAuraId = GetSpellInfo()->Effects[EFFECT_1].CalcValue(); + + Unit* caster = GetCaster(); + if (caster->HasAuraEffect(reqAuraId, 0)) + { + uint32 spellId = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); + caster->CastSpell(caster, spellId, true, NULL); + } } - } - void Register() + void Register() + { + OnEffectHit += SpellEffectFn(spell_q12683_take_sputum_sample_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_q12683_take_sputum_sample_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q12683_take_sputum_sample_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q12683_take_sputum_sample_SpellScript(); - } }; // http://www.wowhead.com/quest=12851 Going Bearback // 54798 FLAMING Arrow Triggered Effect -enum eQuest12851Data +enum Quest12851Data { NPC_FROSTGIANT = 29351, NPC_FROSTWORG = 29358, @@ -634,53 +624,53 @@ enum eQuest12851Data class spell_q12851_going_bearback : public SpellScriptLoader { -public: - spell_q12851_going_bearback() : SpellScriptLoader("spell_q12851_going_bearback") { } - - class spell_q12851_going_bearback_AuraScript : public AuraScript - { public: - PrepareAuraScript(spell_q12851_going_bearback_AuraScript) - void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) + spell_q12851_going_bearback() : SpellScriptLoader("spell_q12851_going_bearback") { } + + class spell_q12851_going_bearback_AuraScript : public AuraScript { - if (Unit* caster = GetCaster()) + PrepareAuraScript(spell_q12851_going_bearback_AuraScript); + + void HandleEffectApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { - Unit* target = GetTarget(); - if (Player* player = caster->GetCharmerOrOwnerPlayerOrPlayerItself()) + if (Unit* caster = GetCaster()) { - switch (target->GetEntry()) + Unit* target = GetTarget(); + if (Player* player = caster->GetCharmerOrOwnerPlayerOrPlayerItself()) { - case NPC_FROSTWORG: - target->CastSpell(player, SPELL_FROSTWORG_CREDIT, true); - target->CastSpell(target, SPELL_IMMOLATION, true); - target->CastSpell(target, SPELL_ABLAZE, true); - break; - case NPC_FROSTGIANT: - target->CastSpell(player, SPELL_FROSTGIANT_CREDIT, true); - target->CastSpell(target, SPELL_IMMOLATION, true); - target->CastSpell(target, SPELL_ABLAZE, true); - break; + switch (target->GetEntry()) + { + case NPC_FROSTWORG: + target->CastSpell(player, SPELL_FROSTWORG_CREDIT, true); + target->CastSpell(target, SPELL_IMMOLATION, true); + target->CastSpell(target, SPELL_ABLAZE, true); + break; + case NPC_FROSTGIANT: + target->CastSpell(player, SPELL_FROSTGIANT_CREDIT, true); + target->CastSpell(target, SPELL_IMMOLATION, true); + target->CastSpell(target, SPELL_ABLAZE, true); + break; + } } } } - } - void Register() + void Register() + { + AfterEffectApply += AuraEffectApplyFn(spell_q12851_going_bearback_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + } + + }; + + AuraScript* GetAuraScript() const { - AfterEffectApply += AuraEffectApplyFn(spell_q12851_going_bearback_AuraScript::HandleEffectApply, EFFECT_0, SPELL_AURA_PERIODIC_DUMMY, AURA_EFFECT_HANDLE_REAL_OR_REAPPLY_MASK); + return new spell_q12851_going_bearback_AuraScript(); } - - }; - - AuraScript* GetAuraScript() const - { - return new spell_q12851_going_bearback_AuraScript(); - } }; // http://www.wowhead.com/quest=12937 Relief for the Fallen // 55804 Healing Finished -enum eQuest12937Data +enum Quest12937Data { SPELL_TRIGGER_AID_OF_THE_EARTHEN = 55809, NPC_FALLEN_EARTHEN_DEFENDER = 30035, @@ -688,50 +678,50 @@ enum eQuest12937Data class spell_q12937_relief_for_the_fallen : public SpellScriptLoader { -public: - spell_q12937_relief_for_the_fallen() : SpellScriptLoader("spell_q12937_relief_for_the_fallen") { } - - class spell_q12937_relief_for_the_fallen_SpellScript : public SpellScript - { public: - PrepareSpellScript(spell_q12937_relief_for_the_fallen_SpellScript) - bool Validate(SpellInfo const* /*spellEntry*/) - { - if (!sSpellMgr->GetSpellInfo(SPELL_TRIGGER_AID_OF_THE_EARTHEN)) - return false; - return true; - } + spell_q12937_relief_for_the_fallen() : SpellScriptLoader("spell_q12937_relief_for_the_fallen") { } - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_q12937_relief_for_the_fallen_SpellScript : public SpellScript { - Unit* pCaster = GetCaster(); - if (Player* player = pCaster->ToPlayer()) + PrepareSpellScript(spell_q12937_relief_for_the_fallen_SpellScript); + + bool Load() { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_TRIGGER_AID_OF_THE_EARTHEN)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); if (Creature* target = GetHitCreature()) { - player->CastSpell(player, SPELL_TRIGGER_AID_OF_THE_EARTHEN, true, NULL); - player->KilledMonsterCredit(NPC_FALLEN_EARTHEN_DEFENDER, 0); + caster->CastSpell(caster, SPELL_TRIGGER_AID_OF_THE_EARTHEN, true, NULL); + caster->KilledMonsterCredit(NPC_FALLEN_EARTHEN_DEFENDER, 0); target->DespawnOrUnsummon(); } } - } - void Register() + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q12937_relief_for_the_fallen_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q12937_relief_for_the_fallen_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q12937_relief_for_the_fallen_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q12937_relief_for_the_fallen_SpellScript(); - } }; -enum eWhoarethey +enum Whoarethey { - SPELL_QUESTGIVER = 48917, - SPELL_MALE_DISGUISE = 38080, SPELL_FEMALE_DISGUISE = 38081, SPELL_GENERIC_DISGUISE = 32756 @@ -748,7 +738,7 @@ class spell_q10041_q10040_who_are_they : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SPELL_QUESTGIVER)) + if (!sSpellMgr->GetSpellInfo(SPELL_MALE_DISGUISE) || !sSpellMgr->GetSpellInfo(SPELL_FEMALE_DISGUISE) || !sSpellMgr->GetSpellInfo(SPELL_GENERIC_DISGUISE)) return false; return true; } @@ -756,11 +746,11 @@ class spell_q10041_q10040_who_are_they : public SpellScriptLoader void HandleScript(SpellEffIndex effIndex) { PreventHitDefaultEffect(effIndex); - if (!GetHitUnit() || !GetHitUnit()->ToPlayer()) - return; - - GetHitUnit()->CastSpell(GetHitUnit(), GetHitUnit()->getGender() == GENDER_MALE ? SPELL_MALE_DISGUISE : SPELL_FEMALE_DISGUISE, true); - GetHitUnit()->CastSpell(GetHitUnit(), SPELL_GENERIC_DISGUISE, true); + if (Player* target = GetHitPlayer()) + { + target->CastSpell(target, target->getGender() == GENDER_MALE ? SPELL_MALE_DISGUISE : SPELL_FEMALE_DISGUISE, true); + target->CastSpell(target, SPELL_GENERIC_DISGUISE, true); + } } void Register() @@ -783,79 +773,81 @@ enum symboloflife // 8593 Symbol of life dummy class spell_symbol_of_life_dummy : public SpellScriptLoader { -public: - spell_symbol_of_life_dummy() : SpellScriptLoader("spell_symbol_of_life_dummy") { } + public: + spell_symbol_of_life_dummy() : SpellScriptLoader("spell_symbol_of_life_dummy") { } - class spell_symbol_of_life_dummy_SpellScript : public SpellScript - { - PrepareSpellScript(spell_symbol_of_life_dummy_SpellScript); - - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_symbol_of_life_dummy_SpellScript : public SpellScript { - if (Creature* target = GetHitCreature()) + PrepareSpellScript(spell_symbol_of_life_dummy_SpellScript); + + void HandleDummy(SpellEffIndex /*effIndex*/) { - if (target->HasAura(SPELL_PERMANENT_FEIGN_DEATH)) + if (Creature* target = GetHitCreature()) { - target->RemoveAurasDueToSpell(SPELL_PERMANENT_FEIGN_DEATH); - target->SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0); - target->SetUInt32Value(UNIT_FIELD_FLAGS_2, 0); - target->SetHealth(target->GetMaxHealth() / 2); - target->SetPower(POWER_MANA, uint32(target->GetMaxPower(POWER_MANA) * 0.75f)); + if (target->HasAura(SPELL_PERMANENT_FEIGN_DEATH)) + { + target->RemoveAurasDueToSpell(SPELL_PERMANENT_FEIGN_DEATH); + target->SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0); + target->SetUInt32Value(UNIT_FIELD_FLAGS_2, 0); + target->SetHealth(target->GetMaxHealth() / 2); + target->SetPower(POWER_MANA, uint32(target->GetMaxPower(POWER_MANA) * 0.75f)); + } } } - } - void Register() + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_symbol_of_life_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_symbol_of_life_dummy_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_symbol_of_life_dummy_SpellScript(); - }; + return new spell_symbol_of_life_dummy_SpellScript(); + }; }; // http://www.wowhead.com/quest=12659 Scalps! // 52090 Ahunae's Knife -enum eQuest12659Data +enum Quest12659Data { NPC_SCALPS_KC_BUNNY = 28622, }; class spell_q12659_ahunaes_knife : public SpellScriptLoader { -public: - spell_q12659_ahunaes_knife() : SpellScriptLoader("spell_q12659_ahunaes_knife") { } + public: + spell_q12659_ahunaes_knife() : SpellScriptLoader("spell_q12659_ahunaes_knife") { } - class spell_q12659_ahunaes_knife_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q12659_ahunaes_knife_SpellScript); - - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_q12659_ahunaes_knife_SpellScript : public SpellScript { - Player* caster = GetCaster()->ToPlayer(); - if (!caster) - return; + PrepareSpellScript(spell_q12659_ahunaes_knife_SpellScript); - if (Creature* target = GetTargetUnit()->ToCreature()) + bool Load() { - target->ForcedDespawn(); - caster->KilledMonsterCredit(NPC_SCALPS_KC_BUNNY, 0); + return GetCaster()->GetTypeId() == TYPEID_PLAYER; } - } - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + if (Creature* target = GetHitCreature()) + { + target->ForcedDespawn(); + caster->KilledMonsterCredit(NPC_SCALPS_KC_BUNNY, 0); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q12659_ahunaes_knife_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHitTarget += SpellEffectFn(spell_q12659_ahunaes_knife_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q12659_ahunaes_knife_SpellScript(); - }; + return new spell_q12659_ahunaes_knife_SpellScript(); + }; }; enum StoppingTheSpread @@ -875,16 +867,21 @@ class spell_q9874_liquid_fire : public SpellScriptLoader { PrepareSpellScript(spell_q9874_liquid_fire_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleDummy(SpellEffIndex /*effIndex*/) { Player* caster = GetCaster()->ToPlayer(); - Creature* target = GetHitUnit()->ToCreature(); - if (!caster || !target || (target && target->HasAura(SPELL_FLAMES))) - return; - - caster->KilledMonsterCredit(NPC_VILLAGER_KILL_CREDIT, 0); - target->CastSpell(target, SPELL_FLAMES, true); - target->DespawnOrUnsummon(60000); + if (Creature* target = GetHitCreature()) + if (target && target->HasAura(SPELL_FLAMES)) + { + caster->KilledMonsterCredit(NPC_VILLAGER_KILL_CREDIT, 0); + target->CastSpell(target, SPELL_FLAMES, true); + target->DespawnOrUnsummon(60000); + } } void Register() @@ -915,16 +912,20 @@ class spell_q12805_lifeblood_dummy : public SpellScriptLoader { PrepareSpellScript(spell_q12805_lifeblood_dummy_SpellScript); + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + void HandleScript(SpellEffIndex /*effIndex*/) { Player* caster = GetCaster()->ToPlayer(); - Creature* target = GetHitUnit()->ToCreature(); - if (!caster || !target) - return; - - caster->KilledMonsterCredit(NPC_SHARD_KILL_CREDIT, 0); - target->CastSpell(target, uint32(GetEffectValue()), true); - target->DespawnOrUnsummon(2000); + if (Creature* target = GetHitCreature()) + { + caster->KilledMonsterCredit(NPC_SHARD_KILL_CREDIT, 0); + target->CastSpell(target, uint32(GetEffectValue()), true); + target->DespawnOrUnsummon(2000); + } } void Register() @@ -945,37 +946,38 @@ class spell_q12805_lifeblood_dummy : public SpellScriptLoader 59643 Plant Horde Battle Standard 4338 Plant Alliance Battle Standard */ -enum eBattleStandard +enum BattleStandard { NPC_KING_OF_THE_MOUNTAINT_KC = 31766, }; class spell_q13280_13283_plant_battle_standard: public SpellScriptLoader { -public: - spell_q13280_13283_plant_battle_standard() : SpellScriptLoader("spell_q13280_13283_plant_battle_standard") { } + public: + spell_q13280_13283_plant_battle_standard() : SpellScriptLoader("spell_q13280_13283_plant_battle_standard") { } - class spell_q13280_13283_plant_battle_standard_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q13280_13283_plant_battle_standard_SpellScript) - void HandleDummy(SpellEffIndex /*effIndex*/) + class spell_q13280_13283_plant_battle_standard_SpellScript : public SpellScript { - Unit* caster = GetCaster(); - if (caster->IsVehicle()) - if (Unit* player = caster->GetVehicleKit()->GetPassenger(0)) - player->ToPlayer()->KilledMonsterCredit(NPC_KING_OF_THE_MOUNTAINT_KC, 0); - } + PrepareSpellScript(spell_q13280_13283_plant_battle_standard_SpellScript); - void Register() + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (caster->IsVehicle()) + if (Unit* player = caster->GetVehicleKit()->GetPassenger(0)) + player->ToPlayer()->KilledMonsterCredit(NPC_KING_OF_THE_MOUNTAINT_KC, 0); + } + + void Register() + { + OnEffectHit += SpellEffectFn(spell_q13280_13283_plant_battle_standard_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const { - OnEffectHit += SpellEffectFn(spell_q13280_13283_plant_battle_standard_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + return new spell_q13280_13283_plant_battle_standard_SpellScript(); } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q13280_13283_plant_battle_standard_SpellScript(); - } }; enum ChumTheWaterSummons @@ -988,42 +990,36 @@ enum ChumTheWaterSummons class spell_q14112_14145_chum_the_water: public SpellScriptLoader { -public: - spell_q14112_14145_chum_the_water() : SpellScriptLoader("spell_q14112_14145_chum_the_water") { } + public: + spell_q14112_14145_chum_the_water() : SpellScriptLoader("spell_q14112_14145_chum_the_water") { } - class spell_q14112_14145_chum_the_water_SpellScript : public SpellScript - { - PrepareSpellScript(spell_q14112_14145_chum_the_water_SpellScript); - - bool Validate(SpellInfo const* /*spellEntry*/) + class spell_q14112_14145_chum_the_water_SpellScript : public SpellScript { - if (!sSpellMgr->GetSpellInfo(SUMMON_ANGRY_KVALDIR)) - return false; - if (!sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_MAKO)) - return false; - if (!sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_THRESHER)) - return false; - if (!sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_BLUE_SHARK)) - return false; - return true; - } + PrepareSpellScript(spell_q14112_14145_chum_the_water_SpellScript); - void HandleScriptEffect(SpellEffIndex /*effIndex*/) + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SUMMON_ANGRY_KVALDIR) || !sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_MAKO) || !sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_THRESHER) || !sSpellMgr->GetSpellInfo(SUMMON_NORTH_SEA_BLUE_SHARK)) + return false; + return true; + } + + void HandleScriptEffect(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + caster->CastSpell(caster, RAND(SUMMON_ANGRY_KVALDIR, SUMMON_NORTH_SEA_MAKO, SUMMON_NORTH_SEA_THRESHER, SUMMON_NORTH_SEA_BLUE_SHARK)); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_q14112_14145_chum_the_water_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); + } + }; + + SpellScript* GetSpellScript() const { - Unit* caster = GetCaster(); - caster->CastSpell(caster, RAND(SUMMON_ANGRY_KVALDIR, SUMMON_NORTH_SEA_MAKO, SUMMON_NORTH_SEA_THRESHER, SUMMON_NORTH_SEA_BLUE_SHARK)); + return new spell_q14112_14145_chum_the_water_SpellScript(); } - - void Register() - { - OnEffectHitTarget += SpellEffectFn(spell_q14112_14145_chum_the_water_SpellScript::HandleScriptEffect, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT); - } - }; - - SpellScript* GetSpellScript() const - { - return new spell_q14112_14145_chum_the_water_SpellScript(); - } }; // http://old01.wowhead.com/quest=9452 - Red Snapper - Very Tasty! @@ -1041,15 +1037,16 @@ class spell_q9452_cast_net: public SpellScriptLoader class spell_q9452_cast_net_SpellScript : public SpellScript { - PrepareSpellScript(spell_q9452_cast_net_SpellScript) + PrepareSpellScript(spell_q9452_cast_net_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } void HandleDummy(SpellEffIndex /*effIndex*/) { Player* caster = GetCaster()->ToPlayer(); - - if (!caster) - return; - switch (urand(0, 2)) { case 0: case 1: diff --git a/src/server/scripts/Spells/spell_rogue.cpp b/src/server/scripts/Spells/spell_rogue.cpp index c88d7b891..3a4132f62 100644 --- a/src/server/scripts/Spells/spell_rogue.cpp +++ b/src/server/scripts/Spells/spell_rogue.cpp @@ -21,7 +21,8 @@ * Scriptnames of files in this file should be prefixed with "spell_rog_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" enum RogueSpells @@ -29,120 +30,114 @@ enum RogueSpells ROGUE_SPELL_SHIV_TRIGGERED = 5940, ROGUE_SPELL_GLYPH_OF_PREPARATION = 56819, ROGUE_SPELL_PREY_ON_THE_WEAK = 58670, + ROGUE_SPELL_CHEAT_DEATH_COOLDOWN = 31231, }; // Cheat Death class spell_rog_cheat_death : public SpellScriptLoader { -public: - spell_rog_cheat_death() : SpellScriptLoader("spell_rog_cheat_death") { } + public: + spell_rog_cheat_death() : SpellScriptLoader("spell_rog_cheat_death") { } - class spell_rog_cheat_death_AuraScript : public AuraScript - { - PrepareAuraScript(spell_rog_cheat_death_AuraScript); - - uint32 absorbChance; - - enum Spell + class spell_rog_cheat_death_AuraScript : public AuraScript { - ROG_SPELL_CHEAT_DEATH_COOLDOWN = 31231, + PrepareAuraScript(spell_rog_cheat_death_AuraScript); + + uint32 absorbChance; + + bool Validate(SpellInfo const* /*spellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(ROGUE_SPELL_CHEAT_DEATH_COOLDOWN)) + return false; + return true; + } + + bool Load() + { + absorbChance = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); + return GetUnitOwner()->ToPlayer(); + } + + void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) + { + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount) + { + Player* target = GetTarget()->ToPlayer(); + if (dmgInfo.GetDamage() < target->GetHealth() || target->HasSpellCooldown(ROGUE_SPELL_CHEAT_DEATH_COOLDOWN) || !roll_chance_i(absorbChance)) + return; + + target->CastSpell(target, ROGUE_SPELL_CHEAT_DEATH_COOLDOWN, true); + target->AddSpellCooldown(ROGUE_SPELL_CHEAT_DEATH_COOLDOWN, 0, time(NULL) + 60); + + uint32 health10 = target->CountPctFromMaxHealth(10); + + // hp > 10% - absorb hp till 10% + if (target->GetHealth() > health10) + absorbAmount = dmgInfo.GetDamage() - target->GetHealth() + health10; + // hp lower than 10% - absorb everything + else + absorbAmount = dmgInfo.GetDamage(); + } + + void Register() + { + DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_cheat_death_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); + OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_cheat_death_AuraScript::Absorb, EFFECT_0); + } }; - bool Validate(SpellInfo const* /*spellEntry*/) + AuraScript* GetAuraScript() const { - return sSpellMgr->GetSpellInfo(ROG_SPELL_CHEAT_DEATH_COOLDOWN); + return new spell_rog_cheat_death_AuraScript(); } - - bool Load() - { - absorbChance = GetSpellInfo()->Effects[EFFECT_0].CalcValue(); - return GetUnitOwner()->ToPlayer(); - } - - void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) - { - // Set absorbtion amount to unlimited - amount = -1; - } - - void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount) - { - Unit* target = GetTarget(); - if (dmgInfo.GetDamage() < target->GetHealth()) - return; - if (target->ToPlayer()->HasSpellCooldown(ROG_SPELL_CHEAT_DEATH_COOLDOWN)) - return; - if (!roll_chance_i(absorbChance)) - return; - - target->CastSpell(target, ROG_SPELL_CHEAT_DEATH_COOLDOWN, true); - target->ToPlayer()->AddSpellCooldown(ROG_SPELL_CHEAT_DEATH_COOLDOWN, 0, time(NULL) + 60); - - uint32 health10 = target->CountPctFromMaxHealth(10); - - // hp > 10% - absorb hp till 10% - if (target->GetHealth() > health10) - absorbAmount = dmgInfo.GetDamage() - target->GetHealth() + health10; - // hp lower than 10% - absorb everything - else - absorbAmount = dmgInfo.GetDamage(); - } - - void Register() - { - DoEffectCalcAmount += AuraEffectCalcAmountFn(spell_rog_cheat_death_AuraScript::CalculateAmount, EFFECT_0, SPELL_AURA_SCHOOL_ABSORB); - OnEffectAbsorb += AuraEffectAbsorbFn(spell_rog_cheat_death_AuraScript::Absorb, EFFECT_0); - } - }; - - AuraScript* GetAuraScript() const - { - return new spell_rog_cheat_death_AuraScript(); - } }; // 31130 - Nerves of Steel class spell_rog_nerves_of_steel : public SpellScriptLoader { -public: - spell_rog_nerves_of_steel() : SpellScriptLoader("spell_rog_nerves_of_steel") { } + public: + spell_rog_nerves_of_steel() : SpellScriptLoader("spell_rog_nerves_of_steel") { } - class spell_rog_nerves_of_steel_AuraScript : public AuraScript - { - PrepareAuraScript(spell_rog_nerves_of_steel_AuraScript); - - uint32 absorbPct; - - bool Load() + class spell_rog_nerves_of_steel_AuraScript : public AuraScript { - absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster()); - return true; - } + PrepareAuraScript(spell_rog_nerves_of_steel_AuraScript); - void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) + uint32 absorbPct; + + bool Load() + { + absorbPct = GetSpellInfo()->Effects[EFFECT_0].CalcValue(GetCaster()); + return true; + } + + void CalculateAmount(AuraEffect const* /*aurEff*/, int32 & amount, bool & /*canBeRecalculated*/) + { + // Set absorbtion amount to unlimited + amount = -1; + } + + void Absorb(AuraEffect* /*aurEff*/, DamageInfo & dmgInfo, uint32 & absorbAmount) + { + // reduces all damage taken while stun or fear + if (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1<GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_FLEEING) || (GetTarget()->GetUInt32Value(UNIT_FIELD_FLAGS) & (UNIT_FLAG_STUNNED) && GetTarget()->HasAuraWithMechanic(1<GetTypeId() == TYPEID_PLAYER; + } + bool Validate(SpellInfo const* /*spellEntry*/) { if (!sSpellMgr->GetSpellInfo(ROGUE_SPELL_GLYPH_OF_PREPARATION)) @@ -162,12 +163,10 @@ class spell_rog_preparation : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; + Player* caster = GetCaster()->ToPlayer(); //immediately finishes the cooldown on certain Rogue abilities - const SpellCooldowns& cm = caster->ToPlayer()->GetSpellCooldownMap(); + const SpellCooldowns& cm = caster->GetSpellCooldownMap(); for (SpellCooldowns::const_iterator itr = cm.begin(); itr != cm.end();) { SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(itr->first); @@ -176,14 +175,14 @@ class spell_rog_preparation : public SpellScriptLoader { if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_COLDB_SHADOWSTEP || // Cold Blood, Shadowstep spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_VAN_EVAS_SPRINT) // Vanish, Evasion, Sprint - caster->ToPlayer()->RemoveSpellCooldown((itr++)->first, true); + caster->RemoveSpellCooldown((itr++)->first, true); else if (caster->HasAura(ROGUE_SPELL_GLYPH_OF_PREPARATION)) { if (spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_DISMANTLE || // Dismantle spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_KICK || // Kick (spellInfo->SpellFamilyFlags[0] & SPELLFAMILYFLAG_ROGUE_BLADE_FLURRY && // Blade Flurry spellInfo->SpellFamilyFlags[1] & SPELLFAMILYFLAG1_ROGUE_BLADE_FLURRY)) - caster->ToPlayer()->RemoveSpellCooldown((itr++)->first, true); + caster->RemoveSpellCooldown((itr++)->first, true); else ++itr; } @@ -216,7 +215,8 @@ public: class spell_rog_prey_on_the_weak_AuraScript : public AuraScript { - PrepareAuraScript(spell_rog_prey_on_the_weak_AuraScript) + PrepareAuraScript(spell_rog_prey_on_the_weak_AuraScript); + bool Validate(SpellInfo const* /*spellEntry*/) { if (!sSpellMgr->GetSpellInfo(ROGUE_SPELL_PREY_ON_THE_WEAK)) @@ -259,7 +259,13 @@ class spell_rog_shiv : public SpellScriptLoader class spell_rog_shiv_SpellScript : public SpellScript { - PrepareSpellScript(spell_rog_shiv_SpellScript) + PrepareSpellScript(spell_rog_shiv_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + bool Validate(SpellInfo const* /*spellEntry*/) { if (!sSpellMgr->GetSpellInfo(ROGUE_SPELL_SHIV_TRIGGERED)) @@ -270,9 +276,6 @@ class spell_rog_shiv : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { Unit* caster = GetCaster(); - if (caster->GetTypeId() != TYPEID_PLAYER) - return; - if (Unit* unitTarget = GetHitUnit()) caster->CastSpell(unitTarget, ROGUE_SPELL_SHIV_TRIGGERED, true); } @@ -297,8 +300,7 @@ class spell_rog_deadly_poison : public SpellScriptLoader class spell_rog_deadly_poison_SpellScript : public SpellScript { - PrepareSpellScript(spell_rog_deadly_poison_SpellScript) - + PrepareSpellScript(spell_rog_deadly_poison_SpellScript); bool Load() { @@ -309,13 +311,10 @@ class spell_rog_deadly_poison : public SpellScriptLoader void HandleBeforeHit() { - Unit* target = GetHitUnit(); - if (!target) - return; - - // Deadly Poison - if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x10000, 0x80000, 0, GetCaster()->GetGUID())) - _stackAmount = aurEff->GetBase()->GetStackAmount(); + if (Unit* target = GetHitUnit()) + // Deadly Poison + if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_AURA_PERIODIC_DAMAGE, SPELLFAMILY_ROGUE, 0x10000, 0x80000, 0, GetCaster()->GetGUID())) + _stackAmount = aurEff->GetBase()->GetStackAmount(); } void HandleAfterHit() @@ -324,49 +323,50 @@ class spell_rog_deadly_poison : public SpellScriptLoader return; Player* player = GetCaster()->ToPlayer(); - Unit* target = GetHitUnit(); - if (!target) - return; - Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND); - - if (item == GetCastItem()) - item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND); - - if (!item) - return; - - // item combat enchantments - for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot) + if (Unit* target = GetHitUnit()) { - SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot))); - if (!enchant) - continue; - for (uint8 s = 0; s < 3; ++s) + Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_MAINHAND); + + if (item == GetCastItem()) + item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND); + + if (!item) + return; + + // item combat enchantments + for (uint8 slot = 0; slot < MAX_ENCHANTMENT_SLOT; ++slot) { - if (enchant->type[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL) + SpellItemEnchantmentEntry const* enchant = sSpellItemEnchantmentStore.LookupEntry(item->GetEnchantmentId(EnchantmentSlot(slot))); + if (!enchant) continue; - SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->spellid[s]); - if (!spellInfo) + for (uint8 s = 0; s < 3; ++s) { - sLog->outError("Player::CastItemCombatSpell Enchant %i, player (Name: %s, GUID: %u) cast unknown spell %i", enchant->ID, player->GetName(), player->GetGUIDLow(), enchant->spellid[s]); - continue; + if (enchant->type[s] != ITEM_ENCHANTMENT_TYPE_COMBAT_SPELL) + continue; + + SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(enchant->spellid[s]); + if (!spellInfo) + { + sLog->outError("Player::CastItemCombatSpell Enchant %i, player (Name: %s, GUID: %u) cast unknown spell %i", enchant->ID, player->GetName(), player->GetGUIDLow(), enchant->spellid[s]); + continue; + } + + // Proc only rogue poisons + if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON) + continue; + + // Do not reproc deadly + if (spellInfo->SpellFamilyFlags.IsEqual(0x10000, 0x80000, 0)) + continue; + + if (spellInfo->IsPositive()) + player->CastSpell(player, enchant->spellid[s], true, item); + else + player->CastSpell(target, enchant->spellid[s], true, item); } - - // Proc only rogue poisons - if (spellInfo->SpellFamilyName != SPELLFAMILY_ROGUE || spellInfo->Dispel != DISPEL_POISON) - continue; - - // Do not reproc deadly - if (spellInfo->SpellFamilyFlags.IsEqual(0x10000, 0x80000, 0)) - continue; - - if (spellInfo->IsPositive()) - player->CastSpell(player, enchant->spellid[s], true, item); - else - player->CastSpell(target, enchant->spellid[s], true, item); } } } diff --git a/src/server/scripts/Spells/spell_shaman.cpp b/src/server/scripts/Spells/spell_shaman.cpp index b0116d6d3..96ee7a184 100644 --- a/src/server/scripts/Spells/spell_shaman.cpp +++ b/src/server/scripts/Spells/spell_shaman.cpp @@ -21,7 +21,10 @@ * Scriptnames of files in this file should be prefixed with "spell_sha_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "GridNotifiers.h" +#include "Unit.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" enum ShamanSpells @@ -94,9 +97,7 @@ class spell_sha_fire_nova : public SpellScriptLoader bool Validate(SpellInfo const* spellEntry) { - if (!sSpellMgr->GetSpellInfo(SHAMAN_SPELL_FIRE_NOVA_R1)) - return false; - if (sSpellMgr->GetFirstSpellInChain(SHAMAN_SPELL_FIRE_NOVA_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id)) + if (!sSpellMgr->GetSpellInfo(SHAMAN_SPELL_FIRE_NOVA_R1) || sSpellMgr->GetFirstSpellInChain(SHAMAN_SPELL_FIRE_NOVA_R1) != sSpellMgr->GetFirstSpellInChain(spellEntry->Id)) return false; uint8 rank = sSpellMgr->GetSpellRank(spellEntry->Id); @@ -119,13 +120,15 @@ class spell_sha_fire_nova : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); - if (uint32 spellId = sSpellMgr->GetSpellWithRank(SHAMAN_SPELL_FIRE_NOVA_TRIGGERED_R1, rank)) + if (Unit* caster = GetCaster()) { - Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[1]); - if (totem && totem->isTotem()) - caster->CastSpell(totem, spellId, true); + uint8 rank = sSpellMgr->GetSpellRank(GetSpellInfo()->Id); + if (uint32 spellId = sSpellMgr->GetSpellWithRank(SHAMAN_SPELL_FIRE_NOVA_TRIGGERED_R1, rank)) + { + Creature* totem = caster->GetMap()->GetCreature(caster->m_SummonSlot[1]); + if (totem && totem->isTotem()) + caster->CastSpell(totem, spellId, true); + } } } @@ -154,30 +157,28 @@ class spell_sha_mana_tide_totem : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SHAMAN_SPELL_GLYPH_OF_MANA_TIDE)) - return false; - if (!sSpellMgr->GetSpellInfo(SHAMAN_SPELL_MANA_TIDE_TOTEM)) + if (!sSpellMgr->GetSpellInfo(SHAMAN_SPELL_GLYPH_OF_MANA_TIDE) || !sSpellMgr->GetSpellInfo(SHAMAN_SPELL_MANA_TIDE_TOTEM)) return false; return true; } void HandleDummy(SpellEffIndex /*effIndex*/) { - Unit* caster = GetCaster(); - if (Unit* unitTarget = GetHitUnit()) - { - if (unitTarget->getPowerType() == POWER_MANA) + if (Unit* caster = GetCaster()) + if (Unit* unitTarget = GetHitUnit()) { - int32 effValue = GetEffectValue(); - // Glyph of Mana Tide - if (Unit* owner = caster->GetOwner()) - if (AuraEffect* dummy = owner->GetAuraEffect(SHAMAN_SPELL_GLYPH_OF_MANA_TIDE, 0)) - effValue += dummy->GetAmount(); - // Regenerate 6% of Total Mana Every 3 secs - int32 effBasePoints0 = int32(CalculatePctN(unitTarget->GetMaxPower(POWER_MANA), effValue)); - caster->CastCustomSpell(unitTarget, SHAMAN_SPELL_MANA_TIDE_TOTEM, &effBasePoints0, NULL, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID()); + if (unitTarget->getPowerType() == POWER_MANA) + { + int32 effValue = GetEffectValue(); + // Glyph of Mana Tide + if (Unit* owner = caster->GetOwner()) + if (AuraEffect* dummy = owner->GetAuraEffect(SHAMAN_SPELL_GLYPH_OF_MANA_TIDE, 0)) + effValue += dummy->GetAmount(); + // Regenerate 6% of Total Mana Every 3 secs + int32 effBasePoints0 = int32(CalculatePctN(unitTarget->GetMaxPower(POWER_MANA), effValue)); + caster->CastCustomSpell(unitTarget, SHAMAN_SPELL_MANA_TIDE_TOTEM, &effBasePoints0, NULL, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID()); + } } - } } void Register() @@ -204,22 +205,20 @@ class spell_sha_earthbind_totem : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(SHAMAN_TOTEM_SPELL_EARTHBIND_TOTEM)) - return false; - if (!sSpellMgr->GetSpellInfo(SHAMAN_TOTEM_SPELL_EARTHEN_POWER)) + if (!sSpellMgr->GetSpellInfo(SHAMAN_TOTEM_SPELL_EARTHBIND_TOTEM) || !sSpellMgr->GetSpellInfo(SHAMAN_TOTEM_SPELL_EARTHEN_POWER)) return false; return true; } void HandleEffectPeriodic(AuraEffect const* aurEff) { - Unit* target = GetTarget(); - if (Unit* caster = aurEff->GetBase()->GetCaster()) - if (TempSummon* summon = caster->ToTempSummon()) - if (Unit* owner = summon->GetOwner()) - if (AuraEffect* aur = owner->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 2289, 0)) - if (roll_chance_i(aur->GetBaseAmount()) && target->HasAuraWithMechanic(1 << MECHANIC_SNARE)) - caster->CastSpell(caster, SHAMAN_TOTEM_SPELL_EARTHEN_POWER, true, NULL, aurEff); + if (Unit* target = GetTarget()) + if (Unit* caster = aurEff->GetBase()->GetCaster()) + if (TempSummon* summon = caster->ToTempSummon()) + if (Unit* owner = summon->GetOwner()) + if (AuraEffect* aur = owner->GetDummyAuraEffect(SPELLFAMILY_SHAMAN, 2289, 0)) + if (roll_chance_i(aur->GetBaseAmount()) && target->HasAuraWithMechanic(1 << MECHANIC_SNARE)) + caster->CastSpell(caster, SHAMAN_TOTEM_SPELL_EARTHEN_POWER, true, NULL, aurEff); } void Register() @@ -257,7 +256,8 @@ class spell_sha_bloodlust : public SpellScriptLoader void ApplyDebuff() { - GetHitUnit()->CastSpell(GetHitUnit(), SHAMAN_SPELL_SATED, true); + if (Unit* target = GetHitUnit()) + target->CastSpell(target, SHAMAN_SPELL_SATED, true); } void Register() @@ -298,7 +298,8 @@ class spell_sha_heroism : public SpellScriptLoader void ApplyDebuff() { - GetHitUnit()->CastSpell(GetHitUnit(), SHAMAN_SPELL_EXHAUSTION, true); + if (Unit* target = GetHitUnit()) + target->CastSpell(target, SHAMAN_SPELL_EXHAUSTION, true); } void Register() @@ -316,6 +317,232 @@ class spell_sha_heroism : public SpellScriptLoader } }; +enum AncestralAwakeningProc +{ + SPELL_ANCESTRAL_AWAKENING_PROC = 52752, +}; + +class spell_sha_ancestral_awakening_proc : public SpellScriptLoader +{ + public: + spell_sha_ancestral_awakening_proc() : SpellScriptLoader("spell_sha_ancestral_awakening_proc") { } + + class spell_sha_ancestral_awakening_proc_SpellScript : public SpellScript + { + PrepareSpellScript(spell_sha_ancestral_awakening_proc_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_ANCESTRAL_AWAKENING_PROC)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + if (GetCaster() && GetHitUnit()) + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_ANCESTRAL_AWAKENING_PROC, &damage, NULL, NULL, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_sha_ancestral_awakening_proc_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_sha_ancestral_awakening_proc_SpellScript(); + } +}; + +enum CleansingTotemPulse +{ + SPELL_CLEANSING_TOTEM_EFFECT = 52025, +}; + +class spell_sha_cleansing_totem_pulse : public SpellScriptLoader +{ + public: + spell_sha_cleansing_totem_pulse() : SpellScriptLoader("spell_sha_cleansing_totem_pulse") { } + + class spell_sha_cleansing_totem_pulse_SpellScript : public SpellScript + { + PrepareSpellScript(spell_sha_cleansing_totem_pulse_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_CLEANSING_TOTEM_EFFECT)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 bp = 1; + if (GetCaster() && GetHitUnit() && GetOriginalCaster()) + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_CLEANSING_TOTEM_EFFECT, NULL, &bp, NULL, true, NULL, NULL, GetOriginalCaster()->GetGUID()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_sha_cleansing_totem_pulse_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_sha_cleansing_totem_pulse_SpellScript(); + } +}; + +enum HealingStreamTotem +{ + SPELL_GLYPH_OF_HEALING_STREAM_TOTEM = 55456, + ICON_ID_RESTORATIVE_TOTEMS = 338, + SPELL_HEALING_STREAM_TOTEM_HEAL = 52042, +}; + +class spell_sha_healing_stream_totem : public SpellScriptLoader +{ + public: + spell_sha_healing_stream_totem() : SpellScriptLoader("spell_sha_healing_stream_totem") { } + + class spell_sha_healing_stream_totem_SpellScript : public SpellScript + { + PrepareSpellScript(spell_sha_healing_stream_totem_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_GLYPH_OF_HEALING_STREAM_TOTEM) || !sSpellMgr->GetSpellInfo(SPELL_HEALING_STREAM_TOTEM_HEAL)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + SpellInfo const* triggeringSpell = GetTriggeringSpell(); + if (Unit* target = GetHitUnit()) + if (Unit* caster = GetCaster()) + { + if (Unit* owner = caster->GetOwner()) + { + if (triggeringSpell) + damage = int32(owner->SpellHealingBonus(target, triggeringSpell, damage, HEAL)); + + // Restorative Totems + if (AuraEffect* dummy = owner->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, ICON_ID_RESTORATIVE_TOTEMS, 1)) + AddPctN(damage, dummy->GetAmount()); + + // Glyph of Healing Stream Totem + if (AuraEffect const* aurEff = owner->GetAuraEffect(SPELL_GLYPH_OF_HEALING_STREAM_TOTEM, EFFECT_0)) + AddPctN(damage, aurEff->GetAmount()); + } + caster->CastCustomSpell(target, SPELL_HEALING_STREAM_TOTEM_HEAL, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID()); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_sha_healing_stream_totem_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_sha_healing_stream_totem_SpellScript(); + } +}; + +enum ManaSpringTotem +{ + SPELL_MANA_SPRING_TOTEM_ENERGIZE = 52032, +}; + +class spell_sha_mana_spring_totem : public SpellScriptLoader +{ + public: + spell_sha_mana_spring_totem() : SpellScriptLoader("spell_sha_mana_spring_totem") { } + + class spell_sha_mana_spring_totem_SpellScript : public SpellScript + { + PrepareSpellScript(spell_sha_mana_spring_totem_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_MANA_SPRING_TOTEM_ENERGIZE)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + if (Unit* target = GetHitUnit()) + if (Unit* caster = GetCaster()) + if (target->getPowerType() == POWER_MANA) + caster->CastCustomSpell(target, SPELL_MANA_SPRING_TOTEM_ENERGIZE, &damage, 0, 0, true, 0, 0, GetOriginalCaster()->GetGUID()); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_sha_mana_spring_totem_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + + }; + + SpellScript* GetSpellScript() const + { + return new spell_sha_mana_spring_totem_SpellScript(); + } +}; + +class spell_sha_lava_lash : public SpellScriptLoader +{ + public: + spell_sha_lava_lash() : SpellScriptLoader("spell_sha_lava_lash") { } + + class spell_sha_lava_lash_SpellScript : public SpellScript + { + PrepareSpellScript(spell_sha_lava_lash_SpellScript) + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + if (Player* caster = GetCaster()->ToPlayer()) + { + int32 damage = GetEffectValue(); + int32 hitDamage = GetHitDamage(); + if (caster->GetItemByPos(INVENTORY_SLOT_BAG_0, EQUIPMENT_SLOT_OFFHAND)) + { + // Damage is increased by 25% if your off-hand weapon is enchanted with Flametongue. + if (caster->GetAuraEffect(SPELL_AURA_DUMMY, SPELLFAMILY_SHAMAN, 0x200000, 0, 0)) + AddPctN(hitDamage, damage); + SetHitDamage(hitDamage); + } + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_sha_lava_lash_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY); + } + + }; + + SpellScript* GetSpellScript() const + { + return new spell_sha_lava_lash_SpellScript(); + } +}; + + void AddSC_shaman_spell_scripts() { new spell_sha_astral_shift(); @@ -324,4 +551,9 @@ void AddSC_shaman_spell_scripts() new spell_sha_earthbind_totem(); new spell_sha_bloodlust(); new spell_sha_heroism(); + new spell_sha_ancestral_awakening_proc(); + new spell_sha_cleansing_totem_pulse(); + new spell_sha_healing_stream_totem(); + new spell_sha_mana_spring_totem(); + new spell_sha_lava_lash(); } diff --git a/src/server/scripts/Spells/spell_warlock.cpp b/src/server/scripts/Spells/spell_warlock.cpp index 51b2de5d0..1bb531be4 100644 --- a/src/server/scripts/Spells/spell_warlock.cpp +++ b/src/server/scripts/Spells/spell_warlock.cpp @@ -21,8 +21,8 @@ * Scriptnames of files in this file should be prefixed with "spell_warl_". */ -#include "ScriptPCH.h" -#include "Spell.h" +#include "ScriptMgr.h" +#include "SpellScript.h" #include "SpellAuraEffects.h" enum WarlockSpells @@ -99,15 +99,7 @@ class spell_warl_demonic_empowerment : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS)) - return false; - if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER)) - return false; - if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD)) - return false; - if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER)) - return false; - if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_IMP)) + if (!sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_SUCCUBUS) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_VOIDWALKER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELGUARD) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_FELHUNTER) || !sSpellMgr->GetSpellInfo(WARLOCK_DEMONIC_EMPOWERMENT_IMP)) return false; return true; } @@ -172,9 +164,7 @@ class spell_warl_create_healthstone : public SpellScriptLoader bool Validate(SpellInfo const* /*spellEntry*/) { - if (!sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R1)) - return false; - if (!sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R2)) + if (!sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R1) || !sSpellMgr->GetSpellInfo(WARLOCK_IMPROVED_HEALTHSTONE_R2)) return false; return true; } @@ -267,7 +257,8 @@ public: void HandleDummy(SpellEffIndex /*effIndex*/) { - GetCaster()->CastSpell(GetCaster(), GetEffectValue(), true); + Unit* caster = GetCaster(); + caster->CastSpell(caster, GetEffectValue(), true); } void Register() @@ -293,7 +284,8 @@ class spell_warl_seed_of_corruption : public SpellScriptLoader void FilterTargets(std::list& unitList) { - unitList.remove(GetTargetUnit()); + if (GetTargetUnit()) + unitList.remove(GetTargetUnit()); } void Register() @@ -308,6 +300,147 @@ class spell_warl_seed_of_corruption : public SpellScriptLoader } }; +enum Soulshatter +{ + SPELL_SOULSHATTER = 32835, +}; + +class spell_warl_soulshatter : public SpellScriptLoader +{ + public: + spell_warl_soulshatter() : SpellScriptLoader("spell_warl_soulshatter") { } + + class spell_warl_soulshatter_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warl_soulshatter_SpellScript); + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_SOULSHATTER)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + if (target->CanHaveThreatList() && target->getThreatManager().getThreat(caster) > 0.0f) + { + sLog->outString("THREATREDUCTION"); + caster->CastSpell(target, SPELL_SOULSHATTER, true); + } else + sLog->outString("can have threat? %b . threat number? %f ",target->CanHaveThreatList(),target->getThreatManager().getThreat(caster)); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warl_soulshatter_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warl_soulshatter_SpellScript(); + } +}; + +enum LifeTap +{ + SPELL_LIFE_TAP_RANK_6 = 11689, + SPELL_LIFE_TAP_RANK_7 = 27222, + SPELL_LIFE_TAP_RANK_8 = 57946, + SPELL_LIFE_TAP_ENERGIZE = 31818, + SPELL_LIFE_TAP_ENERGIZE_2 = 32553, + ICON_ID_IMPROVED_LIFE_TAP = 208, + ICON_ID_MANA_FEED = 1982, +}; + +class spell_warl_life_tap : public SpellScriptLoader +{ + public: + spell_warl_life_tap() : SpellScriptLoader("spell_warl_life_tap") { } + + class spell_warl_life_tap_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warl_life_tap_SpellScript); + + bool Load() + { + return GetCaster()->GetTypeId() == TYPEID_PLAYER; + } + + bool Validate(SpellInfo const* /*spell*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_RANK_6) || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_RANK_7) + || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_RANK_8) || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE) + || !sSpellMgr->GetSpellInfo(SPELL_LIFE_TAP_ENERGIZE_2)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /*effIndex*/) + { + Player* caster = GetCaster()->ToPlayer(); + if (Unit* target = GetHitUnit()) + { + SpellInfo const* spellInfo = GetSpellInfo(); + float spFactor = 0.0f; + int32 damage = int32(GetEffectValue() + (6.3875 * spellInfo->BaseLevel)); + switch (spellInfo->Id) + { + case SPELL_LIFE_TAP_RANK_6: spFactor = 0.2f; break; + case SPELL_LIFE_TAP_RANK_7: + case SPELL_LIFE_TAP_RANK_8: spFactor = 0.5f; break; + default: break; + } + + int32 mana = int32(damage + (caster->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS+SPELL_SCHOOL_SHADOW) * spFactor)); + + // Shouldn't Appear in Combat Log + target->ModifyHealth(-damage); + + // Improved Life Tap mod + if (AuraEffect const* aurEff = caster->GetDummyAuraEffect(SPELLFAMILY_WARLOCK, ICON_ID_IMPROVED_LIFE_TAP, 0)) + AddPctN(mana, aurEff->GetAmount()); + + caster->CastCustomSpell(target, SPELL_LIFE_TAP_ENERGIZE, &mana, NULL, NULL, false); + + // Mana Feed + int32 manaFeedVal = 0; + if (AuraEffect const* aurEff = caster->GetAuraEffect(SPELL_AURA_ADD_FLAT_MODIFIER, SPELLFAMILY_WARLOCK, ICON_ID_MANA_FEED, 0)) + manaFeedVal = aurEff->GetAmount(); + + if (manaFeedVal > 0) + { + ApplyPctN(manaFeedVal, mana); + caster->CastCustomSpell(caster, SPELL_LIFE_TAP_ENERGIZE_2, &manaFeedVal, NULL, NULL, true, NULL); + } + } + } + + SpellCastResult CheckCast() + { + if ((int32(GetCaster()->GetHealth()) > int32(GetSpellInfo()->Effects[EFFECT_0].CalcValue() + (6.3875 * GetSpellInfo()->BaseLevel)))) + { + return SPELL_CAST_OK; + } + return SPELL_FAILED_FIZZLE; + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warl_life_tap_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + OnCheckCast += SpellCheckCastFn(spell_warl_life_tap_SpellScript::CheckCast); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warl_life_tap_SpellScript(); + } +}; + void AddSC_warlock_spell_scripts() { new spell_warl_banish(); @@ -316,4 +449,6 @@ void AddSC_warlock_spell_scripts() new spell_warl_everlasting_affliction(); new spell_warl_ritual_of_doom_effect(); new spell_warl_seed_of_corruption(); + new spell_warl_soulshatter(); + new spell_warl_life_tap(); } diff --git a/src/server/scripts/Spells/spell_warrior.cpp b/src/server/scripts/Spells/spell_warrior.cpp index f39ad3d14..1084398c3 100644 --- a/src/server/scripts/Spells/spell_warrior.cpp +++ b/src/server/scripts/Spells/spell_warrior.cpp @@ -21,7 +21,9 @@ * Scriptnames of files in this file should be prefixed with "spell_warr_". */ -#include "ScriptPCH.h" +#include "ScriptMgr.h" +#include "SpellScript.h" +#include "SpellAuraEffects.h" enum WarriorSpells { @@ -46,8 +48,11 @@ class spell_warr_last_stand : public SpellScriptLoader void HandleDummy(SpellEffIndex /*effIndex*/) { - int32 healthModSpellBasePoints0 = int32(GetCaster()->CountPctFromMaxHealth(30)); - GetCaster()->CastCustomSpell(GetCaster(), WARRIOR_SPELL_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, NULL, NULL, true, NULL); + if (Unit* caster = GetCaster()) + { + int32 healthModSpellBasePoints0 = int32(caster->CountPctFromMaxHealth(30)); + caster->CastCustomSpell(caster, WARRIOR_SPELL_LAST_STAND_TRIGGERED, &healthModSpellBasePoints0, NULL, NULL, true, NULL); + } } void Register() @@ -74,7 +79,8 @@ class spell_warr_improved_spell_reflection : public SpellScriptLoader void FilterTargets(std::list& unitList) { - unitList.remove(GetCaster()); + if (GetCaster()) + unitList.remove(GetCaster()); } void Register() @@ -115,23 +121,19 @@ public: void OnApply(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { - Unit* target = GetTarget(); - target->CastSpell(target, SPELL_DAMAGE_REDUCTION_AURA, true); + if (Unit* target = GetTarget()) + target->CastSpell(target, SPELL_DAMAGE_REDUCTION_AURA, true); } void OnRemove(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/) { - Unit* target = GetTarget(); - - if (!target->HasAura(SPELL_DAMAGE_REDUCTION_AURA)) - return; - - if (target->HasAura(SPELL_BLESSING_OF_SANCTUARY) || - target->HasAura(SPELL_GREATER_BLESSING_OF_SANCTUARY) || - target->HasAura(SPELL_RENEWED_HOPE)) - return; - - target->RemoveAurasDueToSpell(SPELL_DAMAGE_REDUCTION_AURA); + if (Unit* target = GetTarget()) + { + if (target->HasAura(SPELL_DAMAGE_REDUCTION_AURA) && !(target->HasAura(SPELL_BLESSING_OF_SANCTUARY) || + target->HasAura(SPELL_GREATER_BLESSING_OF_SANCTUARY) || + target->HasAura(SPELL_RENEWED_HOPE))) + target->RemoveAurasDueToSpell(SPELL_DAMAGE_REDUCTION_AURA); + } } void Register() @@ -148,9 +150,278 @@ public: } }; +enum DeepWounds +{ + SPELL_DEEP_WOUNDS_RANK_1 = 12162, + SPELL_DEEP_WOUNDS_RANK_2 = 12850, + SPELL_DEEP_WOUNDS_RANK_3 = 12868, + SPELL_DEEP_WOUNDS_RANK_PERIODIC = 12721, +}; + +class spell_warr_deep_wounds : public SpellScriptLoader +{ + public: + spell_warr_deep_wounds() : SpellScriptLoader("spell_warr_deep_wounds") { } + + class spell_warr_deep_wounds_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_deep_wounds_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_DEEP_WOUNDS_RANK_1) || !sSpellMgr->GetSpellInfo(SPELL_DEEP_WOUNDS_RANK_2) || !sSpellMgr->GetSpellInfo(SPELL_DEEP_WOUNDS_RANK_3)) + return false; + return true; + } + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + if (Unit* target = GetHitUnit()) + if (Unit* caster = GetCaster()) + { + // apply percent damage mods + damage = caster->SpellDamageBonus(target, GetSpellInfo(), damage, SPELL_DIRECT_DAMAGE); + + ApplyPctN(damage, 16 * sSpellMgr->GetSpellRank(GetSpellInfo()->Id)); + + SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(SPELL_DEEP_WOUNDS_RANK_PERIODIC); + uint32 ticks = spellInfo->GetDuration() / spellInfo->Effects[EFFECT_0].Amplitude; + + // Add remaining ticks to damage done + if (AuraEffect const* aurEff = target->GetAuraEffect(SPELL_DEEP_WOUNDS_RANK_PERIODIC, EFFECT_0, caster->GetGUID())) + damage += aurEff->GetAmount() * (ticks - aurEff->GetTickNumber()); + + damage = damage / ticks; + caster->CastCustomSpell(target, SPELL_DEEP_WOUNDS_RANK_PERIODIC, &damage, NULL, NULL, true); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_deep_wounds_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_deep_wounds_SpellScript(); + } +}; + +enum Charge +{ + SPELL_JUGGERNAUT_CRIT_BONUS_TALENT = 64976, + SPELL_JUGGERNAUT_CRIT_BONUS_BUFF = 65156, + SPELL_CHARGE = 34846, +}; + +class spell_warr_charge : public SpellScriptLoader +{ + public: + spell_warr_charge() : SpellScriptLoader("spell_warr_charge") { } + + class spell_warr_charge_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_charge_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_JUGGERNAUT_CRIT_BONUS_TALENT) || !sSpellMgr->GetSpellInfo(SPELL_JUGGERNAUT_CRIT_BONUS_BUFF) || !sSpellMgr->GetSpellInfo(SPELL_CHARGE)) + return false; + return true; + } + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 chargeBasePoints0 = GetEffectValue(); + Unit* caster = GetCaster(); + caster->CastCustomSpell(caster, SPELL_CHARGE, &chargeBasePoints0, NULL, NULL, true); + + //Juggernaut crit bonus + if (caster->HasAura(SPELL_JUGGERNAUT_CRIT_BONUS_TALENT)) + caster->CastSpell(caster, SPELL_JUGGERNAUT_CRIT_BONUS_BUFF, true); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_charge_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_charge_SpellScript(); + } +}; + +enum Slam +{ + SPELL_SLAM = 50783, +}; + +class spell_warr_slam : public SpellScriptLoader +{ + public: + spell_warr_slam() : SpellScriptLoader("spell_warr_slam") { } + + class spell_warr_slam_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_slam_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_SLAM)) + return false; + return true; + } + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 bp0 = GetEffectValue(); + if (GetHitUnit()) + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_SLAM, &bp0, NULL, NULL, true, 0); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_slam_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_slam_SpellScript(); + } +}; + +enum Execute +{ + SPELL_EXECUTE = 20647, + SPELL_GLYPH_OF_EXECUTION = 58367, + ICON_ID_SUDDEN_DEATH = 1989, +}; + +class spell_warr_execute : public SpellScriptLoader +{ + public: + spell_warr_execute() : SpellScriptLoader("spell_warr_execute") { } + + class spell_warr_execute_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_execute_SpellScript); + + bool Validate(SpellInfo const* /*SpellEntry*/) + { + if (!sSpellMgr->GetSpellInfo(SPELL_EXECUTE) || !sSpellMgr->GetSpellInfo(SPELL_GLYPH_OF_EXECUTION)) + return false; + return true; + } + void HandleDummy(SpellEffIndex effIndex) + { + Unit* caster = GetCaster(); + if (Unit* target = GetHitUnit()) + { + SpellInfo const* spellInfo = GetSpellInfo(); + int32 rageUsed = std::min(300 - spellInfo->CalcPowerCost(caster, SpellSchoolMask(spellInfo->SchoolMask)), caster->GetPower(POWER_RAGE)); + int32 newRage = std::max(0, caster->GetPower(POWER_RAGE) - rageUsed); + + // Sudden Death rage save + if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_AURA_PROC_TRIGGER_SPELL, SPELLFAMILY_GENERIC, ICON_ID_SUDDEN_DEATH, EFFECT_0)) + { + int32 ragesave = aurEff->GetSpellInfo()->Effects[EFFECT_1].CalcValue() * 10; + newRage = std::max(newRage, ragesave); + } + + caster->SetPower(POWER_RAGE, uint32(newRage)); + // Glyph of Execution bonus + if (AuraEffect* aurEff = caster->GetAuraEffect(SPELL_GLYPH_OF_EXECUTION, EFFECT_0)) + rageUsed += aurEff->GetAmount() * 10; + + + int32 bp = GetEffectValue() + int32(rageUsed * spellInfo->Effects[effIndex].DamageMultiplier + caster->GetTotalAttackPowerValue(BASE_ATTACK) * 0.2f); + caster->CastCustomSpell(target,SPELL_EXECUTE,&bp,0,0,true,0,0,GetOriginalCaster()->GetGUID()); + } + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_execute_SpellScript::HandleDummy, EFFECT_0, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_execute_SpellScript(); + } +}; + +class spell_warr_concussion_blow : public SpellScriptLoader +{ + public: + spell_warr_concussion_blow() : SpellScriptLoader("spell_warr_concussion_blow") { } + + class spell_warr_concussion_blow_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_concussion_blow_SpellScript); + + void HandleDummy(SpellEffIndex /* effIndex */) + { + SetHitDamage(GetHitDamage() + CalculatePctF(GetHitDamage(),GetCaster()->GetTotalAttackPowerValue(BASE_ATTACK))); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_concussion_blow_SpellScript::HandleDummy, EFFECT_2, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_concussion_blow_SpellScript(); + } +}; + +enum Bloodthirst +{ + SPELL_BLOODTHIRST = 23885, +}; + +class spell_warr_bloodthirst : public SpellScriptLoader +{ + public: + spell_warr_bloodthirst() : SpellScriptLoader("spell_warr_bloodthirst") { } + + class spell_warr_bloodthirst_SpellScript : public SpellScript + { + PrepareSpellScript(spell_warr_bloodthirst_SpellScript); + + void HandleDummy(SpellEffIndex /* effIndex */) + { + int32 damage = GetEffectValue(); + if (GetHitUnit()) + GetCaster()->CastCustomSpell(GetHitUnit(), SPELL_BLOODTHIRST, &damage, NULL, NULL, true, NULL); + } + + void Register() + { + OnEffectHitTarget += SpellEffectFn(spell_warr_bloodthirst_SpellScript::HandleDummy, EFFECT_1, SPELL_EFFECT_DUMMY); + } + }; + + SpellScript* GetSpellScript() const + { + return new spell_warr_bloodthirst_SpellScript(); + } +}; + void AddSC_warrior_spell_scripts() { new spell_warr_last_stand(); new spell_warr_improved_spell_reflection(); new spell_warr_vigilance(); + new spell_warr_deep_wounds(); + new spell_warr_charge(); + new spell_warr_slam(); + new spell_warr_execute(); + new spell_warr_concussion_blow(); + new spell_warr_bloodthirst(); } diff --git a/src/server/scripts/World/go_scripts.cpp b/src/server/scripts/World/go_scripts.cpp index fff01c83d..3dfc85d7e 100644 --- a/src/server/scripts/World/go_scripts.cpp +++ b/src/server/scripts/World/go_scripts.cpp @@ -1312,7 +1312,7 @@ class go_veil_skith_cage : public GameObjectScript (*itr)->AI()->Talk(SAY_FREE_0); (*itr)->GetMotionMaster()->Clear(); } - } + } return false; } }; diff --git a/src/server/shared/Cryptography/WardenKeyGeneration.h b/src/server/shared/Cryptography/WardenKeyGeneration.h new file mode 100644 index 000000000..9b44ab183 --- /dev/null +++ b/src/server/shared/Cryptography/WardenKeyGeneration.h @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2008-2012 TrinityCore + * Copyright (C) 2005-2011 MaNGOS + * + * This program is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with this program. If not, see . + */ + +#include "SHA1.h" + +#ifndef _WARDEN_KEY_GENERATION_H +#define _WARDEN_KEY_GENERATION_H + +class SHA1Randx { +public: + SHA1Randx(uint8 *buff, uint32 size) { + uint32 taken = size/2; + + sh.Initialize(); + sh.UpdateData(buff,taken); + sh.Finalize(); + + memcpy(o1,sh.GetDigest(),20); + + sh.Initialize(); + sh.UpdateData(buff+taken,size-taken); + sh.Finalize(); + + memcpy(o2,sh.GetDigest(),20); + + memset(o0,0x00,20); + + fillUp(); + } + + void generate(uint8 *buf, uint32 sz) { + for(uint32 i=0;i > PreparedStatementMap; #define PREPARE_STATEMENT(a, b, c) m_queries[a] = std::make_pair(strdup(b), c); diff --git a/src/server/shared/Logging/Log.cpp b/src/server/shared/Logging/Log.cpp index abdeace4d..a9bb282cf 100755 --- a/src/server/shared/Logging/Log.cpp +++ b/src/server/shared/Logging/Log.cpp @@ -29,7 +29,7 @@ extern LoginDatabaseWorkerPool LoginDatabase; Log::Log() : raLogfile(NULL), logfile(NULL), gmLogfile(NULL), charLogfile(NULL), - dberLogfile(NULL), chatLogfile(NULL), arenaLogFile(NULL), sqlLogFile(NULL), sqlDevLogFile(NULL), + dberLogfile(NULL), chatLogfile(NULL), arenaLogFile(NULL), sqlLogFile(NULL), sqlDevLogFile(NULL), wardenLogFile(NULL), m_gmlog_per_account(false), m_enableLogDBLater(false), m_enableLogDB(false), m_colored(false) { @@ -73,6 +73,10 @@ Log::~Log() if (sqlDevLogFile != NULL) fclose(sqlDevLogFile); sqlDevLogFile = NULL; + + if (wardenLogFile != NULL) + fclose(wardenLogFile); + wardenLogFile = NULL; } void Log::SetLogLevel(char *Level) @@ -166,6 +170,7 @@ void Log::Initialize() arenaLogFile = openLogFile("ArenaLogFile", NULL, "a"); sqlLogFile = openLogFile("SQLDriverLogFile", NULL, "a"); sqlDevLogFile = openLogFile("SQLDeveloperLogFile", NULL, "a"); + wardenLogFile = openLogFile("Warden.LogFile",NULL,"a"); // Main log file settings m_logLevel = ConfigMgr::GetIntDefault("LogLevel", LOGL_NORMAL); @@ -1055,3 +1060,20 @@ void Log::outErrorST(const char * str, ...) ACE_Stack_Trace st; outError("%s [Stacktrace: %s]", nnew_str, st.c_str()); } + +void Log::outWarden(const char * str, ...) +{ + if (!str) + return; + + if (wardenLogFile) + { + outTimestamp(wardenLogFile); + va_list ap; + va_start(ap, str); + vfprintf(wardenLogFile, str, ap); + fprintf(wardenLogFile, "\n" ); + fflush(wardenLogFile); + va_end(ap); + } +} diff --git a/src/server/shared/Logging/Log.h b/src/server/shared/Logging/Log.h index e81225e9c..8b2a1a43b 100755 --- a/src/server/shared/Logging/Log.h +++ b/src/server/shared/Logging/Log.h @@ -50,7 +50,10 @@ enum DebugLogFilters LOG_FILTER_LOOT = 0x00100000, // Loot related LOG_FILTER_GUILD = 0x00200000, // Guild related LOG_FILTER_TRANSPORTS = 0x00400000, // Transport related - LOG_FILTER_BATTLEFIELD = 0x00800000, // Battlefield related + LOG_FILTER_WARDEN = 0x00800000, // Warden related + LOG_FILTER_BATTLEFIELD = 0x01000000, // Battlefield related +}; + }; enum LogTypes @@ -137,6 +140,7 @@ class Log void outChat( const char * str, ... ) ATTR_PRINTF(2, 3); void outArena( const char * str, ... ) ATTR_PRINTF(2, 3); void outSQLDriver( const char* str, ... ) ATTR_PRINTF(2, 3); + void outWarden( const char * str, ... ) ATTR_PRINTF(2, 3); void outCharDump( const char * str, uint32 account_id, uint32 guid, const char * name ); static void outTimestamp(FILE* file); @@ -169,6 +173,7 @@ class Log FILE* arenaLogFile; FILE* sqlLogFile; FILE* sqlDevLogFile; + FILE* wardenLogFile; // cache values for after initilization use (like gm log per account case) std::string m_logsDir; diff --git a/src/server/shared/Threading/Callback.h b/src/server/shared/Threading/Callback.h index fd7a1130f..3e1e7ac69 100755 --- a/src/server/shared/Threading/Callback.h +++ b/src/server/shared/Threading/Callback.h @@ -96,7 +96,7 @@ class QueryCallback { return _stage; } - + //! Resets all underlying variables (param, result and stage) void Reset() { diff --git a/src/server/shared/Utilities/Util.cpp b/src/server/shared/Utilities/Util.cpp index 6ae43bc68..52ce74be8 100755 --- a/src/server/shared/Utilities/Util.cpp +++ b/src/server/shared/Utilities/Util.cpp @@ -16,6 +16,7 @@ * with this program. If not, see . */ +#include #include "Util.h" #include "utf8.h" #ifdef USE_SFMT_FOR_RNG @@ -529,3 +530,15 @@ void hexEncodeByteArray(uint8* bytes, uint32 arrayLen, std::string& result) result = ss.str(); } +std::string ByteArrayToHexStr(uint8* bytes, uint32 length) +{ + std::ostringstream ss; + for (uint32 i = 0; i < length; ++i) + { + char buffer[4]; + sprintf(buffer, "%02X ", bytes[i]); + ss << buffer; + } + + return ss.str(); +} diff --git a/src/server/shared/Utilities/Util.h b/src/server/shared/Utilities/Util.h index 684b26eea..4c2c19369 100755 --- a/src/server/shared/Utilities/Util.h +++ b/src/server/shared/Utilities/Util.h @@ -378,6 +378,7 @@ bool IsIPAddress(char const* ipaddress); uint32 CreatePIDFile(const std::string& filename); void hexEncodeByteArray(uint8* bytes, uint32 arrayLen, std::string& result); +std::string ByteArrayToHexStr(uint8* bytes, uint32 length); #endif //handler for operations on large flags diff --git a/src/server/worldserver/CMakeLists.txt b/src/server/worldserver/CMakeLists.txt index b3254fe7a..b75dfcfc0 100644 --- a/src/server/worldserver/CMakeLists.txt +++ b/src/server/worldserver/CMakeLists.txt @@ -129,6 +129,8 @@ include_directories( ${CMAKE_SOURCE_DIR}/src/server/game/Spells ${CMAKE_SOURCE_DIR}/src/server/game/Spells/Auras ${CMAKE_SOURCE_DIR}/src/server/game/Tools + ${CMAKE_SOURCE_DIR}/src/server/game/Warden + ${CMAKE_SOURCE_DIR}/src/server/game/Warden/Modules ${CMAKE_SOURCE_DIR}/src/server/game/Weather ${CMAKE_SOURCE_DIR}/src/server/game/World ${CMAKE_SOURCE_DIR}/src/server/authserver/Server diff --git a/src/server/worldserver/TCSoap/TCSoap.cpp b/src/server/worldserver/TCSoap/TCSoap.cpp index 8b7d8c190..26b28b25f 100755 --- a/src/server/worldserver/TCSoap/TCSoap.cpp +++ b/src/server/worldserver/TCSoap/TCSoap.cpp @@ -30,7 +30,7 @@ void TCSoapRunnable::run() soap.accept_timeout = 3; soap.recv_timeout = 5; soap.send_timeout = 5; - if (soap_bind(&soap, m_host.c_str(), m_port, 100) < 0) + if (!soap_valid_socket(soap_bind(&soap, m_host.c_str(), m_port, 100))) { sLog->outError("TCSoap: couldn't bind to %s:%d", m_host.c_str(), m_port); exit(-1); diff --git a/src/server/worldserver/worldserver.conf.dist b/src/server/worldserver/worldserver.conf.dist index df44247c1..ce351fc84 100644 --- a/src/server/worldserver/worldserver.conf.dist +++ b/src/server/worldserver/worldserver.conf.dist @@ -11,6 +11,7 @@ # PERFORMANCE SETTINGS # SERVER LOGGING # SERVER SETTINGS +# WARDEN SETTINGS # PLAYER INTERACTION # CREATURE SETTINGS # CHAT SETTINGS @@ -472,6 +473,7 @@ LogFileLevel = 0 # 1048576 - Anything related to loot # 2097152 - Anything related to guilds # 4194304 - Anything related to transports +# 8388608 - Anything related to Warden anti cheat # # Simply add the values together to create a bitmask. # For more info see enum DebugLogFilters in Log.h @@ -1481,6 +1483,82 @@ AccountInstancesPerHour = 5 # ################################################################################################### +################################################################################################### +# WARDEN SETTINGS +# +# Warden.Enabled +# Description: Enable Warden anticheat system. +# Default: 0 - (Disabled) +# 1 - (Enabled) + +Warden.Enabled = 0 + +# +# Warden.NumMemChecks +# Description: Number of Warden memory checks that are sent to the client each cycle. +# Default: 3 - (Enabled) +# 0 - (Disabled) + +Warden.NumMemChecks = 3 + +# +# Warden.NumOtherChecks +# Description: Number of Warden checks other than memory checks that are added to request +# each checking cycle. +# Default: 7 - (Enabled) +# 0 - (Disabled) + +Warden.NumOtherChecks = 7 + +# +# Warden.LogFile +# Description: Client check fails will be logged here. +# Default: "" - (Disabled) +# "Warden.log" - (Enabled) +# + +Warden.LogFile = "" + +# +# Warden.ClientResponseDelay +# Description: Time (in seconds) before client is getting disconnecting for not responding. +# Default: 600 - (10 Minutes) +# 0 - (Disabled, client won't be kicked) + +Warden.ClientResponseDelay = 600 + +# +# Warden.ClientCheckHoldOff +# Description: Time (in seconds) to wait before sending the next check request to the client. +# A low number increases traffic and load on client and server side. +# Default: 30 - (30 Seconds) +# 0 - (Send check as soon as possible) + +Warden.ClientCheckHoldOff = 30 + +# +# Warden.ClientCheckFailAction +# Description: Default action being taken if a client check failed. Actions can be +# overwritten for each single check via warden_action table in characters +# database. +# Default: 0 - (Disabled, Logging only) +# 1 - (Kick) +# 2 - (Ban) + +Warden.ClientCheckFailAction = 0 + +# +# Warden.BanDuration +# Description: Time (in seconds) an account will be banned if ClientCheckFailAction is set +# to ban. +# Default: 86400 - (24 hours) +# 0 - (Permanent ban) + +Warden.BanDuration = 86400 + +# +################################################################################################### + ################################################################################################### # PLAYER INTERACTION #