The Complete Guide to CrackShot - Shampaggon/CrackShot GitHub Wiki

• Installing CrackShot
• Commands and permissions
• Complete list of modules
• Default weapons
• Sound types
• Mob types
• Hooking into CrackShot
• Frequently asked questions

• Getting started
• Modules and nodes
• Weapons folder
• Item IDs
• Integers for values
• Delays for dummies
• Damage for dummies
• Customizable sounds
• Special variables
• Color codes
• Stackable values

• Weapon title
• Item information
• Shooting
• Sneak
• Fully automatic
• Burst fire
• Ammunition
• Reloads
• Firearm actions
• Scopes and iron sights
• Riot shields
• Sign shops
• Crafting recipes
• Region checks
• Custom death messages
• Headshots
• Backstabs
• Critical hits
• Summon entities
• Base damage on flight time
• Airstrikes
• Explosive devices
• Cluster bombs
• Shrapnel
• Explosions
• Lightning
• Potion effects
• Particle effects
• Fireworks
• Abilities
• Hit events
• Extras

This page should only be used as a reference! Attempting to read through all the modules from top to bottom won't be any different to reading a dictionary. I'd advise playing around with the weapons that are provided by default, as well as having a look at the complete list of modules and then using the table of contents to navigate to the module you have interest in using.

To keep your configuration looking clean, remove any particular module or node that you are not using.
Removed modules and nodes will not be taken into account. It's as simple as that.

It might also be good to remember that:

• All nodes that require a number for a value will default to 0 if no value is provided.
• All nodes that require true or false for a value will default to false if no value is provided.

So if you ever come across Right_Click_To_Shoot: false or Explosion_Delay: 0, you can simply remove them.

CrackShot will load any configuration file that it can find in the 'weapons' folder - the names of the files don't matter. As shown by the default configuration files defaultWeapons.yml and defaultExplosives.yml, you can have multiple weapons in one file. You can even fit all your weapons into one file, if you want. Some people prefer to have an individual file for each weapon, some don't. It's up to you how you want to organize your creations.

Note: If the weapons folder is empty, CrackShot will automatically regenerate the three default configuration files: defaultWeapons.yml, defaultExplosives.yml and defaultAttachments.yml.

Unsure of what the ID of a particular item is? I like to refer this fantastic website. It updates whenever new content is introduced, so it is essentially always up to date.

Note: Some nodes support secondary data values. For example, 98~2 will represent the item ID of Cracked Stone Bricks.

For Minecraft 1.13 or higher, use names instead of numbers, because newer blocks/items may not have a numeric ID. Refer to this website for item names. For example, the item ID of Cracked Stone Bricks (as a name) would be CRACKED_STONE_BRICKS.

Whenever a node requires a number for a value, the number must be an integer or a whole number. In other words: 5 or 32 is supported, but 0.024 or 1.243 is not. Only some nodes support decimal values, such as bullet spread.

Trivia: So what happens if you add decimals to values that do not support it? No, your computer won't explode; the value will simply be considered as zero and will not be taken into account.

All delays in the configuration are in ticks. 20 ticks equate to 1 second.

Quiz: How many seconds would 120 ticks equate to? If you answered with anything other than 6 seconds, there might be a problem...

Whenever a node asks about damage, you must remember that 2 units of damage equates to one heart. If your mathematics is sub-par, that means healthy players can take 20 units of damage before dying.

All sounds follow the format: SOUND-VOLUME-PITCH-DELAY.

• SOUND is the type of sound.
• VOLUME is a value from 0-1 that determines how loud the sound is. Any value greater than 1 increases the range of the sound.
• PITCH is a value from 0-2 that determines the pitch of the sound.
• DELAY is the delay in ticks before the sound is played.

By default, sounds have a PITCH and VOLUME of 1.
View the complete list of sounds to determine which sound is right for you.

All strings, unless otherwise specified, can use four special variables which are automatically converted into their corresponding values upon interaction.

<shooter> - Will be converted into the shooter's name.
<victim> - Will be converted into the victim's name.
<damage> - Will be converted into the total damage dealt.
<flight> - Will be converted into the total flight time of the projectile.

Example: A weapon has Message_Shooter: "You shot <victim> for <damage> damage! Your name is <shooter>!" in the Hit_Events: module. Using this weapon, a player named MrDerp shoots another player named Bieber for 20 damage. The message MrDerp receives will be: "You shot Bieber for 20 damage! Your name is MrDerp!".

All strings in the configuration support color codes &<?>. Be sure to make good use of it!

Note: If a color-code is used in a particular string, that entire string must be surrounded by quotes! For example, this will work - Message_Victim: "&eWhy, hello there.", but this will not - Message_Victim: &eWhy, hello there.

Code    Result

&0 	    Black
&1 	    Dark Blue
&2 	    Dark Green
&3 	    Dark Aqua
&4 	    Dark Red
&5 	    Purple
&6 	    Gold
&7 	    Gray
&8 	    Dark Gray
&9 	    Blue
&a 	    Green
&b 	    Aqua
&c 	    Red
&d 	    Light Purple
&e 	    Yellow
&f 	    White
&k 	    Obfuscated
&l 	    Bold
&m 	    Strikethrough
&n 	    Underline
&o 	    Italic
&r 	    Reset

In the examples below, you may come across (...) in things like:

• Sounds_Acquired: <sound>,(...)
• Firework_Player_Shoot: <firework>,(...)
• Make_Victim_Run_Commmand: <command>|(...)

While at first glance it may appear a little bizarre, (...) simply means that the values are stackable. That is, multiple values are supported.

Examples:

• Sounds_Acquired: <sound1>,<sound2>,<sound3>
• Firework_Player_Shoot: <firework1>,<firework2>
• Make_Victim_Run_Commmand: <command1>|<command2>|<command3>

These are all acceptable. Be sure to pay extra care to the separator that is required for these values; it will usually be either , or | unless otherwise specified.

My_Little_Friend:

This will be the name used to spawn the item using /shot get <weapon>, will be the name used for permissions crackshot.<action>.<weapon>, and will be the same name that appears in the list called by /shot list. It must be unique, must not contain any spaces and must always be the very first node of any weapon.

Example: To spawn the weapon above, one would type /shot get my_little_friend. Similarly, the permission node to use the weapon would be crackshot.use.my_little_friend.

Item_Information:
    Item_Name: <name>
    Item_Type: <itemID> OR <itemID~data>
    Item_Lore: <line1>|<line2>|<line3>|<line4> ... |<line9001>
    Inventory_Control: <group>,(...)
    Melee_Mode: <true/false>
    Melee_Attachment: <weapon title>
    Attachments:
        Type: <main> OR <accessory>
        Info: <weapon title>
        Toggle_Delay: <ticks>
        Sounds_Toggle: <sound>,(...)
    Enchantment_To_Check: <ENCHANTMENT-LEVEL>
    Skip_Name_Check: <true/false>
    Sounds_Acquired: <sound>,(...)
    Remove_Unused_Tag: <true/false>
    Hidden_From_List: <true/false>

The item's display name - the name that the players will see when selecting this item.

Example: By using the color-code for yellow &e, you can color an item's name: "&eA yellow display name"

The ID of the item's type. For example, if you would like the item to be a Bone, you would put Item_Type: 352.

Note: Secondary data values are supported. Simply separate the primary and secondary value with the tilde symbol (~). For example, if you would like the item to be a Pink Dye, you would put Item_Type: 351~9.

Important note - If you are using a block item, the secondary data value you provide must be valid, or Bukkit will set it to zero. Block items are items with an ID from 1-255. Here are some examples:

• Item_Type: 98~2 - 98:2 are Cracked Stone Bricks, so this is valid.
• Item_Type: 98~66 - 98:66 does not exist, so this is invalid and Bukkit will change the item into 98:0.
• Item_Type: 104~23 - 104:23 does not exist, so this is invalid and Bukkit will change the item into 104:0.
• Item_Type: 294~23 - This is valid. 294 is not a block item, so you can have whatever secondary data value you want!

If you provide an invalid secondary data value for a block item, the weapon will not function when used.

The item's description. This is what players will see when hovering their mouse over the item. To indicate a new line, use a vertical bar |.

Example: Item_Name: "&eThis is line one.|&eThis is line two.|&eThis is line three."

The Inventory Control feature is used to limit the amount of specific weapons that can be in the hot bar in order for a weapon to be used, preventing players from having a whole arsenal of weapons that they can switch to and from.

This node represents the group(s) that the weapon belongs to, if any. Use this node with the Inventory_Control section in the general.yml configuration file.

Example: A weapon named Peacekeeper has Inventory_Control: primary_weapons. In the Inventory_Control section of the general.yml file:

    primary_weapons:
        Limit: 2
        Message_Exceeded: "&eYou cannot have more than two primary weapons in the hot bar!"
        Sounds_Exceeded: LAVA_POP-1-1-0

This means that the Peacekeeper can only be used if there are no more than two weapons in the hot bar that belong to the primary_weapons group. The sounds and messages are optional.

If set to true, hitting an entity with this weapon would be the same as hitting the entity with a projectile fired from this weapon. Remember the bolded text very carefully; you should be able to filter out the irrelevant nodes on your own.

If melee-mode is enabled:

• The weapon will no longer fire any projectiles.
• The weapon can be used as a melee attachment by other weapons.
• The weapon will still support the Ammo and Reload modules, but not the Firearm_Action module. Ammo will be taken per hit.
• The Delay_Between_Shots node will represent the delay between each time the weapon can hit someone.
• Headshots are ignored, as they cannot be detected via a melee attack.
• The Damage_Based_On_Flight_Time module will be ignored, as there is no projectile.

For more advanced melee weapons - delays between each swing of the weapon, chainsaws and so forth - consider using the energy projectile type instead.

Trivia: Did you know that weapons using Melee_Mode or Melee_Attachment can be used as ordinary attachments (Type: accessory)?

Represents the weapon-title of a melee weapon. Use this node to make the weapon inherit the melee properties of another weapon. The weapon that you provide must be a valid melee weapon - i.e. have Melee_Mode: true.

Slightly confused? You are encouraged to look at the default weapons Python and Tactical Knife (melee attachment).

Mains (weapons with Type: main) will use the attachment specified in the Info: node. These weapons can switch to their attachments with right click (or left click, if Right_Click_To_Shoot: true). For obvious reasons, such weapons will not have proper access to scoping or dual wield.

Attachments (weapons with Type: accessory) do not require any other nodes in the Item_Information module except for the ones in the Attachments section. They are inaccessible using the list and get commands, and do not support the Explosive_Devices and Firearm_Action modules. They can, however, be used alongside weapons that use the Firearm_Action module.

Slightly confused? You are encouraged to look at the default weapons Carbine (main) and M320 (attachment).

• Type:
  • If the weapon is using an attachment, set this to main and provide the attachment's weapon-title to the Info node. If the weapon is an attachment, set this to accessory.
• Info:
  • This node is only used if the weapon has Type: main. Represents the weapon-title of the attachment that the weapon will use.
• Toggle_Delay:
  • The delay in ticks that the player must wait before the freshly toggled weapon can be fired or toggled again.
• Sounds_Toggle:
  • The sound(s) played whenever the weapon is toggled.

All items with this particular enchantment will be converted into this weapon, given that its item-ID matches as well.

Example: The configuration for a particular weapon named Chuck Norris has Enchantment_To_Check: DAMAGE_ALL-2 and Item_Type: 352. Any item that has an item-ID of 352 as well as a level 2 Sharpness (DAMAGE_ALL) enchantment will be automatically converted into Chuck Norris upon interaction.

List of enchantments:

ARROW_DAMAGE
ARROW_FIRE
ARROW_INFINITE
ARROW_KNOCKBACK
DAMAGE_ALL
DAMAGE_ARTHROPODS
DAMAGE_UNDEAD
DIG_SPEED
DURABILITY
FIRE_ASPECT
KNOCKBACK
LOOT_BONUS_BLOCKS
LOOT_BONUS_MOBS
OXYGEN
PROTECTION_ENVIRONMENTAL
PROTECTION_EXPLOSIONS
PROTECTION_FALL
PROTECTION_FIRE
PROTECTION_PROJECTILE
SILK_TOUCH
THORNS
WATER_WORKER

If set to true, all items matching the item-ID specified in Item_Type will be converted into this weapon.

Example: A weapon named Fishy has Item_Type: 349~7 and Skip_Name_Check: true. Any item that has an ID of 349:7 will be automatically converted into Fishy.

Note: Try to use unused secondary data values to avoid converting ordinary items. For instance, having Item_Type: 264 and Skip_Name_Check: true is generally a bad idea, as all Diamonds (ID: 264) would be converted into that particular weapon.

Important note - if you are using this node, you are advised against providing block items or durability items for the Item_Type node. Block items are items with an ID from 1-255. Durability items are any items with durability levels, such as tools and armor.

The sound(s) heard whenever a player either spawns this item using /shot get, or purchases it through a sign shop.

If true, any unused tags «×» will be removed from the weapon's item name.

Note: The tag cannot be removed from weapons that use the Firearm_Action module.

If true, the weapon will be hidden from the list that appears whenever /shot list is called.

Shooting:
    Disable: <true/false>
    Dual_Wield: <true/false>
    Right_Click_To_Shoot: <true/false>
    Cancel_Left_Click_Block_Damage: <true/false>
    Cancel_Right_Click_Interactions: <true/false>
    Delay_Between_Shots: <ticks>
    Recoil_Amount: <amount>
    Projectile_Amount: <amount>
    Projectile_Type: <snowball/arrow/egg/grenade/flare/fireball/witherskull/energy/splash>
    Projectile_Subtype: <itemID> OR <itemID~data> OR <energy info> OR <true/false>
    Remove_Arrows_On_Impact: <true/false>
    Remove_Bullet_Drop: <true/false>
    Removal_Or_Drag_Delay: <delay-removal>
    Projectile_Speed: <amount>
    Projectile_Damage: <amount>
    Projectile_Flames: <true/false>
    Projectile_Incendiary:
        Enable: <true/false>
        Duration: <ticks>
    Bullet_Spread: <amount>
    Reset_Fall_Distance: <true/false>
    Sounds_Projectile: <sound>,(...)
    Sounds_Shoot: <sound>,(...)

If true, shooting will be disabled entirely. Generally, you would only disable shooting if you decide to turn the weapon into a riot shield or some explosive device.

If true, the weapon will be dual wielded (one weapon held in each hand). Left-clicking the weapon will fire the weapon on the left, while right-clicking the weapon will fire the weapon on the right. Both weapons can be fired simultaneously.

Note: When this node is set to true, the Right_Click_To_Shoot: node will obviously be ignored. The Scope and Firearm_Action: modules will also be ignored.

By default, left-click is used to shoot, while right-click is used for the iron sights (zooming in). Enabling this will switch things around.

Note: In most cases, you would only use right-click to shoot if the weapon is fully-automatic, as holding right-click will cause the player to shoot repeatedly, while holding left-click does not.

Players clicking frantically while shooting a weapon may accidentally break blocks. Setting this node to true will cancel all block-damage for that particular weapon.

Players shooting or zooming with right-click may accidentally interact with buttons, doors and so forth. If the weapon is a block or a minecart, they may also accidentally place it. Setting this node to true will cancel all right-click interactions for that particular weapon.

The delay in ticks that the player must wait before the next shot can be fired.

The force by which the shooter will be pushed back for each shot. A negative value will pull the player forwards; I'm sure one could use that to their imagination.

Note: Shooting a weapon straight down with Recoil_Amount: 40 is enough to send the player airborne for quite a lengthy period of time. A value between 1-10 is recommended, but feel free to experiment.

The number of projectiles that are launched per shot. For shotguns, this would generally be a value greater than one.

There are nine values that you can input: snowball, egg, arrow, grenade, flare, fireball, witherskull, energy, splash.

• Snowballs are highly recommended for ordinary projectiles.
• Eggs are just as recommended as snowballs. Eggs fired from CrackShot weapons do not spawn chickens.
• Arrows are just as recommended as snowballs. When using arrows, you may want to enable the Remove_Arrows_On_Impact node.
• Grenades will launch a grenade in the form of a dropped item, which will explode after a specified amount of time. They do not explode on impact. When a grenade explodes, it will use the settings defined in the Explosions: and Lightning: modules.
• Flares are similar to grenades. Instead of exploding, however, they will call in an airstrike after a certain period of time.
• Fireballs travel in a relatively straight line and explode upon impact. The explosion created is determined by the settings defined in the Explosions: module. You can prevent this projectile from being deflected by setting the Projectile_Subtype node to true.
• Wither skulls are exactly the same as fireballs. The only difference is that they do not explode when hit by other projectiles. Due to a Bukkit bug, wither skulls that score direct-hits on enemies may trigger a "Reach" violation in anti-cheat plugins. Aside from being a nuisance, this has no other effect.
• Splash potions are thrown potions that hit all enemies in a splash radius. These projectiles do not support the Headshot or Damage_Based_On_Flight_Time modules. You can change the color of the splash, and only the splash, by providing a valid splash potion in the Projectile_Subtype node.

Note that fireball and witherskull can never be truly accurate, and do not take the Bullet_Spread: nodes very effectively.

Energy
Energy is an advanced projectile type that hits all enemies in a specified cuboid region in front the player. Think of it as a giant laser-beam.

In the Projectile_Subtype node, you will need to define its size (RADIUS), how far it travels in blocks (RANGE), how many blocks it can pass through before stopping (WALLS) and how many victims it can pass through before stopping (VICTIMS).

If you are using the energy projectile type, the Projectile_Subtype node will follow this format:

• Projectile_Subtype: RANGE-RADIUS-WALLS-VICTIMS

Note that:

• For WALLS, you can input NONE if you want to turn off wall penetration completely, or you can input ALL if you want the projectile to pass through all blocks in its path. Otherwise, specify a number.
• For VICTIMS, you can simply input 0 if you want the projectile to pass through all victims. Otherwise, specify a number.

This projectile type can be used to mimic melee weapons such as chainsaws, area-of-effect weapons such as flamethrowers and highly-penetrative weapons that can pierce through multiple enemies and/or walls.

A value is only necessary if Projectile_Type: is set to grenade, flare, fireball, energy or splash.

• For grenade and flare - This node represents the item-ID of the thrown item-drop.
• For splash - (Optional) This node represents the item-ID of the thrown splash potion. This will only change the color of the splash and must be a valid splash potion.
• For fireball - (Optional) If this node is set to true, then the fireball cannot be deflected.
• For energy - This node will represent the information required for the weapon to fire an energy-type projectile.

Note: Secondary data values are supported. Simply separate the primary and secondary value with the tilde symbol (~). For example, if you would like an item to be a Red Wool, you would put Item_Type: 35~14.

If Projectile_Type: is set to arrow, arrows will be removed immediately upon impact. After all, nobody likes swimming in arrows, especially if a machine-gun has been customized to fire them.

If true, the fired projectile will travel in a straight line and will not be affected by gravity. Affects only snowball, egg and arrow.

Note: Due to a Minecraft visual bug, slow projectiles using this node may appear to bounce in mid-air, while fast projectiles may appear to curve away from the direction they are being fired at.

The delay in ticks before the projectile is either removed (true) or dragged (false).
When a projectile is dragged, its speed is significantly reduced.

Examples:

• Removal_Or_Drag_Delay: 4-true will remove the projectile after 4 ticks.
• Removal_Or_Drag_Delay: 3-false will drastically slow the projectile after 3 ticks.

The speed of the fired projectile(s). A value from 0-40 is recommended. Projectiles with a speed exceeding 40 will begin to show signs of path warping due to a visual bug on Minecraft's side. Anything traveling at a speed above 100 would probably enter another dimension.

The amount of damage each bullet will deal.

If true, the projectile will appear to be set on fire. Affects only snowball, egg, arrow and splash.

Incendiary projectiles will light victims on fire. Provide a duration that determines how long the victims should stay alight for, given that Enable: is set to true.

Remember, this is not accuracy, this is spread. The closer this value is to 0, the more accurate the fired projectiles will be. A value from 0-10 is recommended. Input anything above 10 and the bullet would probably fly out the back of the barrel and hit you in the face.

Note: This node supports decimal values, such as 2.354, 0.22556 or 3.5.

Sometimes a firearm's recoil is so great that you can break falls with it. That's what this node is for. If set to true, each time this weapon is fired, the shooter's fall-damage will be cleared.

Clarification: Yes. You can now jump off a cliff, fire your gun at the feet just before you hit the ground, and survive the fall.

The sound(s) played by the projectile. Use this node for beeping grenades and so forth.

The sound(s) played whenever the weapon is fired.

Sneak:
    Enable: <true/false>
    No_Recoil: <true/false>
    Bullet_Spread: <amount>
    Sneak_Before_Shooting: <true/false>

Whether or not sneaking should be taken into account.

If set to true, the player will experience no recoil while sneaking, that is, the player will not be pushed backwards (or forwards) by the recoil.

The spread of the projectiles fired while sneaking.

Note: This node supports decimal values, such as 2.354, 0.22556 or 3.5.

Trivia: In games like Left 4 Dead 2, you cannot aim down the sights of most weapons. In order to improve accuracy, players will need to crouch while shooting. This is exactly what this node is provided for.

If set to true, the player must crouch by sneaking before being able to shoot. Sneaking while airborne does not count.

Fully_Automatic:
    Enable: <true/false>
    Fire_Rate: <fire-rate>

If enabled, restricts the weapon to a specific rate of fire. It is highly recommended that you use this module with Right_Click_To_Shoot enabled. This is because in Minecraft, holding down right-click allows the player to shoot repeatedly, but holding down left-click does not.

In order to use this module:

• The Burstfire module must be disabled.
• The Delay_Between_Shots node must be removed or set to 1 or 0.
• The value for Fire_Rate must range from 1-16.

Example: See the default AK-47.

This is a value ranging from 1-16 that determines how quickly the weapon can shoot, measured in rounds (or shots) per minute.

    Fire rate    Rounds per minute (RPM)
    
    1            300
    2            360
    3            420
    4            480
    5            540
    6            600
    7            660
    8            720
    9            780
    10           840
    11           900
    12           960
    13           1020
    14           1080
    15           1140
    16           1200

Note: With Fire_Rate: 16, the weapon will shoot once every tick. This is twenty shots per second, and is the highest possible rate of fire in Minecraft.

Burstfire:
    Enable: <true/false>
    Shots_Per_Burst: <amount>
    Delay_Between_Shots_In_Burst: <ticks>

If enabled, allows multiple shots to be fired with a single pull of the trigger.

Note: This module and the Fully_Automatic module cannot be used together.

The amount of shots fired per burst.

The delay between each shot in the burst.

Ammo:
    Enable: <true/false>
    Ammo_Item_ID: <itemID> OR <itemID~data>
    Ammo_Name_Check: <name>
    Take_Ammo_Per_Shot: <true/false>
    Sounds_Out_Of_Ammo: <sound>,(...)
    Sounds_Shoot_With_No_Ammo: <sound>,(...)

Whether or not ammunition should be taken into account.

The ID of the type of item being used as ammunition.

Note: Secondary data values are supported. For example, if you would like the item to be a Pink Dye, you would put Ammo_Item_ID: 351~9.

(Optional) The name of the item being used as ammunition.

Example: A weapon has Ammo_Item_ID: 264, Ammo_Name_Check: "&eGun Ammo" and Take_Ammo_Per_Shot: true. On each shot, 1 Diamond with the name &eGun Ammo (where "&e" is the color-code for yellow) will be taken from the shooter's inventory.

Note: Any item that contains the given name will also be accepted. Continuing with the previous example, each shot could also take 1 Diamond with the name Chocolate &eGun Ammo With Cream.

Whether or not ammunition should be taken from the shooter's inventory after each shot.

Example: A weapon has Ammo_Item_ID: 264 and Take_Ammo_Per_Shot: true. 264 is the ID for Diamond. On each shot, 1 Diamond will be taken from the shooter's inventory. If the shooter has no diamonds, the weapon will not be able to be fired.

The sound(s) played as soon as the final piece of ammunition is fired. In other words, as soon as the player's inventory runs out of the specified ammunition, the sound(s) will be played.

The sound(s) played when a player attempts to shoot a weapon while having no ammunition.

Example: A player trying to shoot a weapon while having no ammunition in his inventory will hear this sound.

Reload:
    Enable: <true/false>
    Reload_With_Mouse: <true/false>
    Starting_Amount: <amount>
    Reload_Amount: <amount>
    Reload_Bullets_Individually: <true/false>
    Take_Ammo_On_Reload: <true/false>
    Take_Ammo_As_Magazine: <true/false>
    Reload_Duration: <ticks>
    Reload_Shoot_Delay: <ticks>
    Destroy_When_Empty: <true/false>
    Sounds_Out_Of_Ammo: <sound>,(...)
    Sounds_Reloading: <sound>,(...)
    Dual_Wield:
        Single_Reload_Duration:
        Sounds_Single_Reload:
        Sounds_Shoot_With_No_Ammo:

Whether or not reloading should be enabled for this weapon. When this node is enabled:

• Q - or the button you use to drop your weapon - will be used to reload. (Unless Reload_With_Mouse: true)
• You can drop weapons normally by dragging them out of your inventory.
• The /shot reload command can be used to reload the weapon.

If set to true, the weapon will be reloaded with the left or right click, depending on whichever mouse button you are using to fire the weapon. Q, or the button you use to drop your weapon, will not longer be used to reload the weapon and you will be able to drop it normally.

The amount of ammo the weapon starts with when it is first spawned. For example, if Reload_Amount is set to 30, and Starting_Amount is set to 15, then the weapon will start off with 15 out of 30 ammo.

This node is optional. If no value is provided, the weapon will spawn with full ammo.

This value essentially determines the magazine capacity of the weapon. In other words, how many bullets can this weapon hold and fire before a reload is required? And how many bullets will be restored to the weapon upon a reload?

Example: Consider the AK-47 from Call of Duty 4. It has a magazine size of 30 bullets. If one were to replicate that weapon, the value of Reload_Amount: would be 30.

If set to true, will reload bullets one by one. This would generally be used for reloading shotguns, bolt-action rifles, revolvers etc.

Similar to the Take_Ammo_Per_Shot node of the Ammo module. Setting this to true will take ammunition from the shooter's inventory upon reload.

Note: This node depends on the information provided in the Ammo module.

Similar to the Take_Ammo_Per_Shot node of the Ammo module. Setting this to true will cause a single item ("magazine") to be taken from the player's inventory upon each reload. If the weapon is being dual wielded, two magazines will be taken for a complete reload, as there are two firearms.

Note: This node depends on the information provided in the Ammo module.

The amount of time in ticks it will take to completely reload the weapon.

The amount of time in ticks before the player can fire the weapon after the reload has been successfully completed.

If set to true, reloading the weapon will not be possible and the weapon will destroy itself as soon as its ammo-reading hits 0.

The sound(s) played as soon as the ammo-reading on the weapon hits 0.

Note: Not to be confused with Sounds_Out_Of_Ammo: of the Ammo: module, which refers to the sound that is played when the player's inventory runs out of physical ammunition.

The sound(s) played when the weapon is being reloaded.

There is a special case for reloading dual wielded weapons. For example: if both weapons are empty, then you would obviously reload both. But what if only one weapon is empty? You would only reload one of the weapons, which would take significantly less time than reloading both weapons at once.

• Single_Reload_Duration:
  • The amount of time in ticks it will take to reload one of the weapons.
• Sounds_Single_Reload:
  • The sound(s) played when a single weapon is being reloaded.
• Sounds_Shoot_With_No_Ammo:
  • The sound(s) played when the player attempts to fire one of the weapons that is out of ammo.

Firearm_Action:
    Type: <slide/bolt/lever/pump/break/revolver>
    Open_Duration: <ticks>
    Close_Duration: <ticks>
    Close_Shoot_Delay: <ticks>
    Reload_Open_Delay: <ticks>
    Reload_Close_Delay: <ticks>
    Sound_Open: <sound>,(...)
    Sound_Close: <sound>,(...)

Input one of the six acceptable values below. Specifying a firearm-action is not compulsory.

• slide

  • Introduces the slide mechanism or charging handle. The weapon will have two states: unlocked ■ and locked □. If the weapon runs out of ammo, the bolt will be locked to the rear ■ ➙ □. In order to shoot again, not only will the weapon need to be reloaded, it will need to have the bolt moved back into its original position □ ➙ ■.

• bolt or lever

  • Bolt-action or lever-action. Introduces three states to the weapon: bullet in firing chamber ■, cartridge-case in firing chamber □, and empty firing chamber _. Every time a bullet is fired, the bolt/lever is opened and closed to re-chamber a new round. Furthermore, the weapon can only be reloaded when the bolt/lever is in the open position _.

• pump

  • Pump-action. Exactly the same as bolt and lever except the weapon does not have to be opened _ for a reload to occur. Suitable for shotguns, as you basically insert shells directly into the weapon.

• break or revolver

  • Upon reload, the weapon must be opened □ and then closed ■ after the reload is complete. Suitable for, as you would have guessed, break-action shotguns, "noob-tubes" and revolvers.

Note: Selecting pump, bolt, or lever will use the delays provided in Open_Duration, Close_Duration and Close_Shoot_Delay to determine the weapon's rate of fire instead of the value provided in Delay_Between_Shots:.

The duration of the (bolt/lever/pump/...) opening.

Note: For the HK slap method of reloading, this node can used by slide weapons.

The duration of the (bolt/lever/pump/slide/...) closing.

The delay until the weapon can be fired again after the bolt, lever, pump or slide closes.

(Optional) This node represents the delay before the reloading of the weapon begins after the weapon is readied ■ ➙ □.

(Optional) This node represents the delay before the closing □ ➙ ■ of the weapon begins after the completion of a successful reload.

The sound(s) of the (...) opening.

The sound(s) of the (...) closing.

Scope:
    Enable: <true/false>
    Night_Vision: <true/false>
    Zoom_Amount: <amount>
    Zoom_Bullet_Spread: <amount>
    Zoom_Before_Shooting: <true/false>
    Sounds_Toggle_Zoom: <sound>,(...)

Whether or not scopes or iron sights should be enabled on the weapon.

Whether or not the scope is a night-vision scope.

The amount of zoom the scope offers. A value between 1-5 is recommended.

The amount of spread the fired projectile should have upon being fired.

Note: This node supports decimal values, such as 2.354, 0.22556 or 3.5.

If true, the player can only shoot if zoomed in.

The sound(s) played when the player zooms in.

Riot_Shield:
    Enable: <true/false>
    Do_Not_Block_Projectiles: <true/false>
    Do_Not_Block_Melee_Attacks: <true/false>
    Durability_Based_On_Damage: <true/false>
    Durability_Loss_Per_Hit: <amount>
    Forcefield_Mode: <true/false>
    Only_Works_While_Blocking: <true/false>
    Sounds_Blocked: <sound>,(...)
    Sounds_Break: <sound>,(...)

If true, allows riot shields to be used. Riot shields are shields that can completely block certain attacks under certain conditions.

If true, the shield will not block ranged attacks when raised.

If true, the shield will not block melee attacks when raised.

If true, Durability_Loss_Per_Hit: will take into account the amount of damage the player has blocked.

Example: A player is holding a certain shield that has Durability_Loss_Per_Hit: 10 and Durability_Based_On_Damage: true. This player successfully uses the shield to block 4 units of damage. The shield will have 4X10 units of durability deducted from it.

The amount of durability that will be deducted from the shield per hit or unit of damage (depending on whether Durability_Based_On_Damage is true.

If true, the riot shield will block attacks from every direction when raised, including attacks directed towards the back of the player. The player will no longer need to face the threat.

If true, the riot shield will only block attacks when the player is blocking. In Minecraft 1.8, blocking is performed by right-clicking with a sword. In Minecraft 1.9 and above, blocking is performed by right-clicking with a shield.

The sound(s) played whenever the shield successfully blocks an attack.

The sound(s) played when the shield runs out of durability and breaks.

SignShops:
    Enable: <true/false>
    Price: <itemID-amount> OR <itemID~data-amount>
    Sign_Gun_ID: <unique number>

Whether or not a store for this weapon is able to be created and purchased from.

Specify the item-type and amount required for a successful transaction. Supports secondary data values - 351~9-5 would equal 5 Pink Dyes.

Example: A weapon named Volleyball has Price: 266-12. 266 is the ID for Gold Ingot, thus, purchasing a Volleyball from a store will cost 12 Gold Ingots.

This must be a unique number from 1-999. There should not be more than one weapon in the configuration that shares the same Sign_Gun_ID: value.

Simply place a sign. In the first line, type [CS]<number>, where <number> is the weapon's Sign_Gun_ID: value (a value between 1 and 999). As long as this first line is correct, and the player has permission to create a store, the player will be receive a Shop successfully created message when the sign has been finalized. You may type anything in the 2nd, 3rd and 4th line.

Note: Players in creative-mode cannot purchase from stores. In order to remove a shop sign, you must be in creative-mode, and you must have the permission to do so - crackshot.store.<weapon>/all.

This sign will use the shop configured in the default weapon Type 95. Note that "&e" is the color code for yellow. You can only color your lines if you have a plugin that handles colored-signs.

Given that the creation was successful, this will be the final result.

Crafting:
    Enable: <true/false>
    Quantity: <amount>
    Shaped: <true/false>
    Ingredients: <ingredients>

If true, allows the weapon to be crafted using the custom recipe provided by the user. Remember, players will still need permission crackshot.craft.<weapon> to craft the weapon.

The number of items that this crafting recipe will output. Defaults to 1.

Do the items need to be placed in certain slots for this to work (shaped)? Or can they be placed anywhere (not shaped)? If Shaped: true, you must provide all 9 values.

The ingredients, with each slot (from 1-9) containing a certain amount of an item.

Example 1: Assume that Shaped: is true for this recipe. Keep in mind that 30 is the item ID for Web, and 98~2 is the item ID for Cracked Stone Bricks. The recipe for the image above would be: Ingredients: 30,0,98~2,0,30,0,98~2,98~2,30. All 9 values must be provided, as it is a shaped recipe. The value of an empty slot is 0.

Example 2: Assume that Shaped: is false for this recipe. The recipe for the image above would be: Ingredients: 30,30,1. You do not need to provide all 9 values, and the order of the items placed on the crafting grid does not matter, as it is an unshaped recipe. Furthermore, Ingredients: 1,30,30 is the same as Ingredients: 30,30,1 is the same as Ingredients: 30,1,30 and so on.

If you are interested in using CrackShot weapons as viable ingredients, you will have to use secondary data values. For instance:

Hunting_Rifle:
    Item_Information:
        Item_Type: 280~1

Hunting_Rifle_Part:
    Item_Information:
        Item_Type: 280~2

Uber_Hunting_Rifle:
    Item_Information:
        Item_Type: 280~3
    Crafting:
        Enable: true
        Shaped: false
        Ingredients: 280~1,280~2

From the simplified example above, you will be able to craft an Uber_Hunting_Rifle using Hunting_Rifle_Part and Hunting_Rifle.

⚠ Note: When using secondary data values to individualize weapons, avoid block items (unless you know what you are doing) and durability items. You will find information about those types of items in the Item Information section of the guide.

Region_Check:
    Enable: <true/false>
    World_And_Coordinates: <worldname,X1,Y1,Z1,X2,Y2,Z2,blacklist>|(...)
    Message_Of_Denial: <message>

If true, the weapon and its projectiles will only be functional if the player or projectile is within/outside the region(s) specified. Useful if you want to restrict the usage of weapons to certain arenas.

Clarification: Weapons will not function if it does not pass the region check. Its projectiles will also fail to function. For example, if you fired a Bazooka or threw a Grenade from outside of a restricted region, the projectile will not explode if it lands inside the restricted region.

Note: Projectiles using the Break_Blocks node will fail to destroy blocks inside a restricted region.

Specify the world name. This is generally the name of the world's folder (e.g. The End is usually world_the_end). Follow this by the X,Y,Z coordinates of point 1 and point 2. Finally, specify whether or not the region is a blacklist with true or false. You may specify multiple regions by separating each region with a vertical bar |.

Note: Supports decimal values such as -356.217, but their use is discouraged. Blacklisted regions will also override whitelisted regions should the two regions overlap.

Examples:

• World_And_Coordinates: world,0,0,0,200,200,200,true - A region blacklist. The weapon cannot be used inside the defined region, but can be used outside of it.
• World_And_Coordinates: world,0,0,0,200,200,200,false - A region whitelist. The weapon can only be used inside the define region, and cannot be used outside of it.
• World_And_Coordinates: world,0,0,0,200,200,200 - Same as the example above. If true or false is not provided for the blacklist variable, it will default to false and become a region whitelist.

The message the player will receive upon being rejected. Does not support any variables.

Custom_Death_Message:
    Normal: <message>
    H̶e̶a̶d̶s̶h̶o̶t̶:̶

The message that will be broadcasted to the entire server when a victim is killed by this weapon. These messages do not support the variables <flight> and <damage>.

This feature has not yet been added, but will aim to broadcast a different message if the victim was killed by a headshot.

Headshot:
    Enable: <true/false>
    Bonus_Damage: <amount>
    Message_Shooter: <message>
    Message_Victim: <message>
    Sounds_Shooter: <sound>,(...)
    Sounds_Victim: <sound>,(...)

Whether or not headshots should be taken into consideration. Applies only to projectiles.

How much extra damage a headshot will deal.

The message the shooter will receive upon delivering a headshot.

The message the victim will receive upon receiving a headshot.

The sound(s) played at the shooter upon delivering a headshot.

The sound(s) played at the victim upon receiving a headshot.

Backstab:
    Enable: <true/false>
    Bonus_Damage: <amount>
    Message_Shooter: <message>
    Message_Victim: <message>
    Sounds_Shooter: <sound>,(...)
    Sounds_Victim: <sound>,(...)

Whether or not backstabs should be taken into consideration. Applies to projectiles and weapons with melee mode.

How much extra damage shooting an entity in the back will deal.

The message the shooter will receive upon delivering a backstab.

The message the victim will receive upon receiving a backstab.

The sound(s) played at the shooter upon delivering a backstab.

The sound(s) played at the victim upon receiving a backstab.

Critical_Hits:
    Enable: <true/false>
    Bonus_Damage: <amount>
    Chance: <percentage>
    Message_Shooter: <message>
    Message_Victim: <message>
    Sounds_Shooter: <sound>,(...)
    Sounds_Victim: <sound>,(...)

Whether or not critical hits should be taken into consideration. Applies to projectiles and weapons with melee mode.

How much extra damage a critical hit will deal.

The percentage chance that the shooter will score a critical hit. Must be a value from 1-100, where 100 means a 100% chance of success.

Example: Chance: 25 will mean that the weapon will have a 25% chance of scoring a critical hit.

The message the shooter will receive upon delivering a critical hit.

The message the victim will receive upon receiving a critical hit.

The sound(s) played at the shooter upon delivering a critical hit.

The sound(s) played at the victim upon receiving a critical hit.

Spawn_Entity_On_Hit:
    Enable: <true/false>
    Chance: <percentage>
    Mob_Name: <name>
    EntityType_Baby_Explode_Amount: <entity-baby-explode-amount>,(...)
    Make_Entities_Target_Victim: <true/false>
    Timed_Death: <ticks>
    Entity_Disable_Drops: <true/false>
    Message_Shooter: <message>
    Message_Victim: <message>

Whether or not entities will be spawned when:

• a projectile fired by the weapon strikes an enemy
• an explosion caused by the weapon damages an enemy

The percentage chance that entities will be spawned when the enemy is hit. Must be a value from 1-100, where 100 means a 100% chance of success.

The name of the spawned mobs. This node is optional.

Specify the entity type, whether or not it is a baby, whether or not it will explode upon death, and the amount. You can spawn more than one type of entity by separating them with a comma ,.

Example: EntityType_Baby_Explode_Amount: PIG-TRUE-TRUE-4 will spawn 4 baby pigs that explode upon death.

Note: An entity that explodes upon death will create an explosion with a radius of 2 (half that of TNT). Furthermore, setting baby to true on a Creeper would turn that Creeper into a Powered Creeper.

Trivia: Did you know that zombies and zombie pigmen have baby forms?

This node is deprecated and may cause mobs to sink into the ground. If true, will attempt make the spawned entities target the victim.

The time in ticks that the spawned entities will live for before dying.

If true, the spawned entities will not drop any items or experience orbs upon death.

The message the shooter will receive upon successfully spawning entities at the victim's position.

The message the victim will receive if entities were successfully spawned.

Damage_Based_On_Flight_Time:
    Enable: <true/false>
    Bonus_Damage_Per_Tick: <amount>
    Minimum_Damage: <amount>
    Maximum_Damage: <amount>

Whether or not the flight-time of the projectile should be taken into consideration upon calculating the total damage dealt to a victim.

Uses: Projectiles can be made to deal much more damage the longer it stays in the air, discouraging players from attempting to shoot enemies point-blank. By setting Bonus_Damage_Per_Tick: to a negative value, and not providing a value for Minimum_Damage, the range of a weapon can be severely limited; perfect for short-ranged shotguns.

The extra damage the projectile will deal upon striking a target after each tick. Can be set to a negative value to reduce damage the longer the projectile stays airborne.

The minimum bonus damage the projectile must exceed to deal any bonus damage at all.

Example: A weapon has Minimum_Damage: 10 and Bonus_Damage_Per_Tick: 2. The weapon fires a projectile that travels for 4 ticks before striking an enemy. During this time, it had gathered a total damage of 8 units. Since 8 falls below the minimum damage of 10, no bonus damage is added to the total damage dealt.

The maximum bonus damage the projectile can gain or lose.

Example: A weapon has Maximum_Damage: 5 and Bonus_Damage_Per_Tick: 2. The weapon fires a projectile that travels for 4 ticks before striking an enemy. During this time, it had gathered a total damage of 8 units. Since 8 exceeds the maximum damage of 5, only 5 units of bonus damage is added to the total damage dealt.

Note: If the value provided in Bonus_Damage_Per_Tick is negative, this node can be used to limit the amount of damage to be deducted! For example, having Maximum_Damage: -4 and Bonus_Damage_Per_Tick: -1 will cause the projectile to deal 1 less unit of damage for every tick it is airborne until 4 ticks have elapsed.

Airstrikes:
    Enable: <true/false>
    Flare_Activation_Delay: <ticks>
    Particle_Call_Airstrike: <particle-effect>,(...)
    Message_Call_Airstrike: <message>
    Block_Type: <itemID> OR <itemID~data>
    Area: <amount>
    Distance_Between_Bombs: <amount>
    Height_Dropped: <amount>
    Vertical_Variation: <amount>
    Horizontal_Variation: <amount>
    Multiple_Strikes:
        Enable: <true/false>
        Number_Of_Strikes: <amount>
        Delay_Between_Strikes: <ticks>
    Sounds_Airstrike: <sound>,(...)

If true, an airstrike will be called whenever a player is struck by an ordinary projectile (snowball, egg, arrow) or when a flare is thrown and activated.

If Projectile_Type: is set to flare, this node will represent the delay in ticks before the thrown flare will call in an airstrike.

The particle effect(s) created when a thrown flare or projectile calls in an airstrike. Visit the Particles module for more information on how particle-effects are formatted.

The message the caller of the airstrike will receive when an airstrike is called. The only special variable this node supports is <shooter>, which represents the caller of the airstrike.

The item ID of the dropped bombs. These item IDs must be blocks. Secondary data values are supported.

Example: Setting Block_Type: to 35~4 will cause the airstrike to drop Yellow Wool as bombs.

Airstrikes drop a square grid of bombs with a certain dimension. This node represents the area of that grid.

Setting Area: to 5 will cause the airstrike to drop 5 X 5 = 25 bombs per strike. Setting Area: to 2 will cause the airstrike to drop 2 X 2 = 4 bombs per strike, and so on.

The distance in blocks between each bomb.

Examples: Setting this node to 0 will pack all the bombs into a single solid unit. Setting this node to 4 will space every individual bomb four blocks apart.

The height in blocks relative to the point of calling from which the bombs will be dropped.

Example: Setting this node to 100 will spawn the bombs 100 blocks above the position of the flare or projectile's point of activation.

The degree of vertical variation, in blocks, between the bombs. This node serves to randomize the nature of the strike.

The degree of horizontal variation, in blocks, between the bombs. This node serves to randomize the nature of the strike.

• Enable: - Whether or not there will be multiple strikes.
• Number_Of_Strikes: - The number of strikes.
• Delay_Between_Strikes: - The delay in ticks between each strike.

The sound(s) played whenever an airstrike is called.

Explosive_Devices:
    Enable: <true/false>
    Device_Type: <landmine> OR <remote> OR <trap> OR <itembomb>
    Device_Info: <information>
    Sounds_Deploy: <sound>,(...)
    Remote_Bypass_Regions: <true/false>
    Message_Disarm: <message>
    Message_Trigger_Placer: <message>
    Message_Trigger_Victim: <message>
    Sounds_Alert_Placer: <sound>,(...)
    Sounds_Trigger: <sound>,(...)

If true, the weapon will become an explosive device. For:

• landmines - the act of shooting will involve planting a mine.

• remote-detonated explosives - the act of shooting will involve placing an explosive mob-head.

• trap - traps are items with the following qualities:

  • Place this in a dispenser; triggering the dispenser will result in an explosion.
  • Place this in a chest; opening the chest will result in an explosion.
  • Drop this item onto the ground; picking it up will result in an explosion.
  • Place this in an item frame; pressure-plates within 4 blocks that are stepped on will result in an explosion.
  • Owners cannot trigger their own traps.

• item bombs - the act of shooting will involve throwing an item-bomb.

Note: This module takes information from the Explosions module to determine the nature of the explosion.

There are currently 4 supported values:

• landmine - Deploys a minecart that will explode upon contact with enemies. These mines are permanent - they will be active even after server restarts - and will also explode if shot by projectiles. Given that the placer is online at the time, friendly-fire checking is implemented, allowing the mine to distinguish between enemies and teammates in environments managed by other plugins, such as Factions or PVPArena. These mines can be used to guard personal property, and can be non-lethal or deadly depending on how you configure it.

• remote - Places an explosive mob-head (Steve) that can be remotely detonated from any world, from any position on the map. Friendly-fire checking is implemented - enemies attempting to break the device will set it off, while allies will not be able to break the device at all. These devices will be disarmed when broken by the person who placed it. Inherits the building properties of the item specified in the Item_Type node of the Item_Information module, so make sure it's a placeable block! Compatible with the Ammo module and the One_Time_Use node.

• trap - An item which will explode when a chest containing the item is opened, when shot out of a dispenser or when picked up by enemies. A trap will not work until a player has given it an owner by activating it. Owners will not be able to trigger their own traps. As usual, friendly-fire checking is implemented as long as the owner is online at the time - allies who attempt to pick up the item or open a chest containing the item will not trigger the device. Note that traps will never run out when fired from dispensers.

  • Pressure-plate mines - traps have one unique property: when placed in an item frame, all pressure-plates within 4 blocks will generate an explosion whenever they are stepped on.

• itembomb - Throws an item that can be remotely detonated from any world, from any position on the map. The thrown item-bombs despawn when the player responsible for throwing them leaves the server. All item-bombs are removed upon server restarts. Compatible with the Ammo module and the One_Time_Use node.

The value for this node differs depending on the device type. For:

• landmine - Assumes the following format: <itemID-minecartType>.

  • itemID represents the item ID of the fuse (the passenger of the minecart). All mines must carry a valid fuse, so a value is required. Supports secondary data values - a value of 35 would represent Wool, while a value of 35~6 would represent Pink Wool.
  • minecartType represents the minecart type. The following types are currently supported: MINECART, MINECART_CHEST, MINECART_FURNACE, MINECART_HOPPER, MINECART_MOB_SPAWNER and MINECART_TNT. This setting should be used by plugin developers only; the inherent properties of other minecart types are not blocked.

• remote - This node assumes the following format: Amount-UniqueID-Headname.

  • Amount determines the maximum number of remote-detonated explosives the weapon can handle.
  • UniqueID must be two characters long, and must contain a value unique to the weapon - no other remote-type weapon should share the same value. UniqueID can contain numbers as well as letters of the alphabet. Not that letters are case insensitive; 1A is the same as 1a.
  • Headname is the player-name that the mob-head will use upon being triggered. It is not possible to specify the player-name of the mob-head before it is triggered; it will always be a Steve head.

• trap - This node assumes the following format: Chest-Pickup-DispenserAndPressurePlate-Reusable-NoItemDespawn. Each value requires a simple true or false.

  • Chest - whether or not the trap will be triggered when a chest containing the item is opened.
  • Pickup - whether or not the trap will be triggered when the dropped item is picked up.
  • DispenserAndPressurePlate - whether or not the trap will be triggered when the item is fired from a dispenser or triggered by a pressure plate within four blocks of a trap mounted on an item frame.
  • Reusable - if set to true will make traps never run out (dropped items can be triggered more than once, and so forth).
  • NoItemDespawn - if set to true will cause the dropped item to never despawn - useful for minefields that are composed of dropped item-traps.

• itembomb - This node assumes the following format: Amount,Speed,Before,After.

  • Amount determines the maximum number of item bombs the player can throw. This limit will be impossible to exceed, even if a player has multiple instances of the same itembomb weapon!
  • Speed determines the speed at which the item bomb is thrown.
  • Before represents the item ID of the item bomb when inert. Secondary data values are supported.
  • After represents the item ID of the item bomb when triggered. Secondary data values are supported.

Examples:

• If Device_Type is set to remote, inputting 4-T7-Notch will create a device that can place and store up to 4 explosives that will turn into Notch-heads upon activation.
• If Device_Type is set to itembomb, inputting 2,10,159,159~14 will create a device that can throw up to 2 item bombs with a speed of 10. These item bombs will look like White Stained Clay (159), but when triggered, will look like Red Stained Clay (159:14).

The sound(s) played when the device is deployed. For:

• landmine - This sound will be played when the mine is placed.

• remote - This sound will be played when an explosive mob-head is placed.

• trap - This sound will be played when the device is first activated by a player.

• itembomb - This sound will be played when an item bomb is thrown.

Used only for remote-type devices. Setting this node to true will bypass all region-protection plugins and allow the placement and removal of remote-detonated explosives anywhere.

Used only for remote-type devices. This will represent the message the placer of the device will receive when breaking and disarming devices that he himself has placed. Supports no special variables.

The message the placer of the device will receive when the device is triggered. Supports all special variables except for <flight> and <damage>.

The message the victim will receive upon triggering an explosive device, such as bumping into a landmine, breaking someone's remote-detonated explosive, or opening a chest containing a booby trap. Supports all special variables except for <flight> and <damage>.

The sound(s) the owner of the device hears when the device is triggered. For:

• landmine - This sound will be played when the mine is triggered by an enemy, alerting the mine-placer to possible victims.

• remote - This sound will be played when a remote-detonated explosive is manually activated by the placer, or when the explosive is set off by someone trying to break it.

• trap - This sound will be played when a booby trap is triggered by either a player opening a chest containing a booby trap, a victim stepping on a pressure-plate within four blocks of an item-frame booby trap, or a player picking up a booby trap item.

• itembomb - This sound will be played when the item bomb is activated by the thrower.

The sound(s) the device makes when triggered. For:

• landmine - This sound will be emitted by the mine when an enemy triggers it.

• remote - This sound will be emitted by the explosive when manually activated by the placer, or when an enemy tries to break it.

• trap - This sound will be emitted by the trap when an enemy opens a chest containing the trap, an enemy picks up a booby trap item, an enemy steps on a pressure-plate within four blocks of an item-frame booby trap, or when the trap is shot out of a dispenser.

• remote - This sound will be emitted by the item bomb when activated by the thrower.

Cluster_Bombs:
    Enable: <true/false>
    Bomblet_Type: <itemID> OR <itemID~data>
    Delay_Before_Split: <ticks>
    Number_Of_Splits: <amount>
    Number_Of_Bomblets: <amount>
    Speed_Of_Bomblets: <amount>
    Delay_Before_Detonation: <ticks>
    Detonation_Delay_Variation: <ticks>
    Particle_Release: <particle-effect>,(...)
    Sounds_Release: <sound>,(...)

If set to true, all explosions caused by the weapon will release cluster bombs (with the exception of the explosions caused by airstrikes). Uses the Explosions module to determine the nature of the bomblet-explosions.

Clarification: Yes, this module can be used for landmines, remote-detonated devices, grenades, booby traps - everything that explodes except for airstrikes. "Oh, but why no airstrike?!" - because frankly, if every bomb of an airstrike were to split and release bomblets, one's computer would probably implode.

The item ID of the released bomblets. Secondary data values are supported.

This node represents the delay in ticks before a cluster bomb splits and releases its bomblets.

This node represents the number of times the cluster bomb will split.

Note: The amount of bomblets released is calculated by Number_Of_Bomblets to the power of Number_Of_Splits. This means having a value of 6 for Number_Of_Splits and a value of 5 for Number_Of_Bomblets will equate to a total of 15,625 (5⁶) bomblets and consequent explosions!

For your own safety, CrackShot will reject cluster bombs that release over 1000 bomblets in total.

The number of bomblets a single cluster bomb will release.

The speed of the released bomblets. The higher the value, the further these bomblets will travel away from the point of release.

The delay before the released bomblets explode.

Clarification: Cluster bombs do not use the Explosion_Delay: node from the Explosions module.

If you do not want all of the bomblets to explode all at once, you can use this node to vary the delay by a specified amount. This node serves to randomize the nature of the explosions.

Example: Delay_Before_Detonation: is set to 40 (2 seconds). Detonation_Delay_Variation: is set to 20 (1 second). This means the bomblets will have a delay of 2±1 seconds before exploding.

The particle effect(s) created when a cluster bomb splits and releases its bomblets. Visit the Particles module for more information on how particle-effects are formatted.

The sound(s) played when a cluster bomb splits and releases its bomblets.

Shrapnel:
    Enable: <true/false>
    Block_Type: <itemID> OR <itemID~data>
    Amount: <amount>
    Speed: <amount>
    Place_Blocks: <true/false>

If set to true, all explosions caused by the weapon will release blocks of "shrapnel".

The item ID of the dropped bombs. These item IDs must be blocks. Secondary data values are supported.

Example: Setting Block_Type: to 35~4 will use Yellow Wool as the shrapnel.

The number of shrapnel released. As always, try to provide an appropriate value.

The speed of the released shrapnel. The larger the value, the further away from the explosion the shrapnel will travel.

If set to true, the shrapnel-blocks will place themselves upon landing. If you had ever wanted an explosion that dispersed water, lava, fire and so forth, then this node is right for you.

Explosions:
    Enable: <true/false>
    Knockback: <amount>
    Ignite_Victims: <ticks>
    Damage_Multiplier: <percentage>
    Enable_Friendly_Fire: <true/false>
    Enable_Owner_Immunity: <true/false>
    Explosion_No_Damage: <true/false>
    Explosion_Potion_Effect: <potioneffect>,(...)
    Explosion_No_Grief: <true/false>
    Explosion_Radius: <amount>
    Explosion_Incendiary: <true/false>
    Explosion_Delay: <ticks>
    On_Impact_With_Anything: <true/false>
    Projectile_Activation_Time: <ticks>
    Message_Shooter: <message>
    Message_Victim: <message>
    Sounds_Shooter: <sound>,(...)
    Sounds_Victim: <sound>,(...)
    Sounds_Explode: <sound>,(...)

If true, enables explosions for the weapon. This module applies to all projectile-types, airstrikes, cluster bombs and explosive devices.

Note: These explosions are compatible with all region-protection plugins such as WorldGuard, Factions, and Towny. If a projectile lands in a region where explosions are disabled, it will be cancelled.

★ CrackShot explosions have advanced friendly-fire checking. Teammates will not be damaged by your explosions.

Provide a value that determines the amount of knockback the explosion will deliver. Negative values are supported.

Example: Giving this node a value of -10 will cause an implosion that pulls everything towards the center.

If the given value is greater than zero, the explosion will set victims on fire. Provide a duration that determines how long the victims should stay alight for.

Note: This node is not to be confused with Explosion_Incendiary:, which sets destroyed blocks on fire.

The percentage to multiply the explosion's damage by.

Example: A value of 50 would cause the explosion to deal half damage (50%). A value of 200 would cause the explosion to deal double damage (200%). Please note that you cannot completely nullify the damage of the explosion by giving this node a value of 0 (0%).

If true, explosions will damage your teammates. In team-based arenas managed by plugins such as MobArena and PVP Arena, it is generally a good idea to leave this node false to prevent team-killing.

Note: Setting this node to true is heavily discouraged, and may cause the explosions to ignore most of the settings in the Explosions: module.

If true, the shooter (the person who caused the explosion) will not be damaged by the explosion, and will not receive any potion-effects (if provided) from the explosion.

If true, the explosion will not deal any damage. This is useful for tactical grenades such as flashbangs or gas grenades, which do not deal any damage but apply potion-effects.

The potion-effect(s) given to victims who are fully exposed to the explosion - enemies taking shelter behind obstacles will be safe. Please refer to the Potion effects section for setting up potion-effects, or have a look at the Flashbang default weapon.

If true, the explosion will not destroy any blocks, paintings, item-frames, or dropped items.

The radius of the explosion. For your own protection, the radius is capped at 20.

Note: The radius of a TNT block is 4. Recommended values are between 1 and 10.

If Explosion_No_Grief: is set to false, setting this node to true will set some of the destroyed blocks on fire. If you would like to light blocks on fire without destroying them, consider using the Shrapnel module.

Note: This node is not to be confused with Ignite_Victims:, which sets victims on fire.

The delay in ticks before the actual explosion occurs. For ordinary projectiles, this can be used for sticky grenades, which explode in a certain amount of time after hitting a victim. For grenade however, this delay determines when the grenade will explode after being thrown.

By default, the projectile will only trigger an explosion when it strikes a living entity. If this node is set to true, the projectile will explode upon impact with anything, which includes blocks and entities. This node does not apply to grenades.

This node represents the time in ticks that the projectile has to be airborne before it is primed to explode upon impact.

Trivia: Grenade launchers from FPS games such as Call of Duty fire grenades that explode upon impact after traveling in the air for a certain amount of time. Firing one straight down at your feet will not cause an explosion.

The message the shooter will receive when the explosion damages an entity. This node supports <shooter> and <victim> as special variables.

The message the victim will receive upon being damaged by the explosion. This node supports <shooter> and <victim> as special variables.

The sound(s) the shooter will hear whenever the explosion damages an entity. Great for hit marker noises.

The sound(s) victims hear when they are hurt by the explosion.

Trivia: This node is used in the default weapon Flashbang to mimic the ringing of the ears that occurs after a loud explosion.

The sound(s) played when the explosion occurs.

Note: This does not replace the TNT-explosion sound. It is merely an addition.

Lightning:
    Enable: <true/false>
    No_Damage: <true/false>
    On_Impact_With_Anything: <true/false>

Whether or not lightning should strike at the projectile's position upon impact.

Note: This module is compatible with the grenade projectile-type! If this module is enabled, the grenade will use it upon detonation.

If the lightning should deal no damage.

By default, the projectile will only trigger a lightning-strike when it collides with a living entity. If this node is set to true, the projectile will call a lightning-strike upon impact with anything, which includes blocks and entities.

Note: Setting this node to true is not recommended unless the use of the weapon is restricted to a controlled environment, as most region-protection plugins do not block lightning in certain regions. You may risk players killing each other with lightning, even in safe-zones.

Potion_Effects:
    Activation: <head,back,crit,hit,shoot,reload>
    Potion_Effect_Shooter: <POTIONTYPE-DURATION-LEVEL>,(...)
    Potion_Effect_Victim: <POTIONTYPE-DURATION-LEVEL>,(...)

ABSORPTION
BLINDNESS
CONFUSION
DAMAGE_RESISTANCE
FAST_DIGGING
FIRE_RESISTANCE
HARM
HEAL
HEALTH_BOOST
HUNGER
INCREASE_DAMAGE
INVISIBILITY
JUMP
NIGHT_VISION
POISON
REGENERATION
SATURATION
SLOW
SLOW_DIGGING
SPEED
WATER_BREATHING
WEAKNESS
WITHER

Specify the event(s) upon which potion effects will be given. head for headshots, back for backstabs, crit for critical hits, hit for normal hits, shoot for every time the player shoots and reload for every time the player reloads.

Example: A weapon has Activation: back,crit. Potion-effects will only be given out if the shooter scores either a backstab or a critical hit.

The potion effect that will be given to the shooter upon activation. Specify a potion type, followed by the duration of the effect in ticks, followed by the level.

Example: Potion_Effect_Victim: SLOW-1200-3,BLINDNESS-60-1 would mean the victim will receive a Slow III potion effect for 60 seconds, and a Blindness I potion effect for 3 seconds.

The potion effect that will be given to the victim upon activation. Works in the same way as Potion_Effect_Shooter:.

Particles:
    Enable: <true/false>
    Particle_Player_Shoot: <particle-effect>,(...)
    Particle_Terrain: <true/false>
    Particle_Impact_Anything: <particle-effect>,(...)
    Particle_Hit: <particle-effect>,(...)
    Particle_Headshot: <particle-effect>,(...)
    Particle_Critical: <particle-effect>,(...)
    Particle_Backstab: <particle-effect>,(...)

There are 6 types of particle effects to choose from. Their format will be outlined below.

smoke - Sends out a puff of smoke.

lightning - Strikes lightning at your position. This is just an effect, and will deal no damage.

explosion - Creates a small "explosion" at your position. This is just an effect, and will deal no damage.

potion_splash-<number> - Creates a splash-potion breaking effect at the player's position. The number that you specify will determine the color of the splash.

block_break-<blockID> Creates a block-break particle effect at the player's position, with the block-type being the ID that you specify.

flames-<amount> - Spawns mob-spawner flames at the player's position. You may specify any number for the amount; it does not cause any visible changes.

Example: A weapon with Particle_Player_Shoot: flames-10,smoke,block_break-55 will create flame, smoke and the block-break particles of redstone wire whenever the player shoots.

Whether or not particle effects are enabled.

The particle effect(s) spawned at the player upon shooting.

If set to true, whenever a projectile (arrow, snowball or egg) strikes a block, it will cause the said block to emit a block break particle effect depending on its block type. A unique effect that makes projectiles appear as though they are damaging the terrain.

The particle effect(s) spawned at the victim upon impact.

The particle effect(s) spawned at the point of impact. Not to be confused with Particle_Hit:, which only activates when a projectile strikes an entity.

The particle effect(s) spawned at the victim when a headshot is delivered.

The particle effect(s) spawned at the victim when a critical hit is delivered.

The particle effect(s) spawned at the victim when a backstab is delivered.

Fireworks:
    Enable: <true/false>
    Firework_Player_Shoot: <firework>,(...)
    Firework_Explode: <firework>,(...)
    Firework_Hit: <firework>,(...)
    Firework_Headshot: <firework>,(...)
    Firework_Critical: <firework>,(...)
    Firework_Backstab: <firework>,(...)

All fireworks follow the following format: TYPE-TRAIL-FLICKER-R-G-B

Specify the firework type, which will either be BALL, BALL_LARGE, BURST, CREEPER or STAR. State whether trail and flicker are enabled using true or false. Finally, provide a value from 0-255 for R, G and B. These values will determine the color of the firework effect.

Example: Firework_Headshot: CREEPER-TRUE-TRUE-255-128-64 would create an orange, creeper-type firework that has a trail and flickers.

Whether or not fireworks are enabled. Fireworks can be emitted whenever the projectile strikes a victim, or whenever a player fires a weapon.

The firework effect(s) spawned at the player upon shooting.

The firework effect(s) spawned during explosions.

The firework effect(s) spawned at the victim upon impact.

The firework effect(s) spawned at the victim when a headshot is delivered.

The firework effect(s) spawned at the victim when a critical hit is delivered.

The firework effect(s) spawned at the victim when a backstab is delivered.

Abilities:
    Super_Effective: <entity-multiplier>,(...)
    Death_No_Drop: <true/false>
    Bonus_Drops: <itemID>,(...)
    Reset_Hit_Cooldown: <true/false>
    Knockback: <amount>
    No_Fall_Damage: <true/false>
    No_Vertical_Recoil: <true/false>
    Hurt_Effect: <true/false>
    Jetpack_Mode: <true/false>
    Break_Blocks: <whitelist-block1,block2,block3,(...)>

Use this node to increase or decrease the damage dealt to players and certain mobs. This applies to the entire weapon, even explosions caused by it. The multiplier value supports decimal places.

List of accepted values for entity type (differs from this list, which is only used for the Spawn_Entity_On_Hit module):

Bat
Blaze
Cave_Spider
Chicken
Cow
Creeper
Ender_Dragon
Enderman
Ghast
Giant
Horse
Iron_Golem
Magma_Cube
Mushroom_Cow
Ocelot
Pig
Pig_Zombie
Player
Sheep
Silverfish
Skeleton
Slime
Snowman
Spider
Squid
Villager
Witch
Wither
Wolf
Zombie

Example usage: Super_Effective: PLAYER-0,WITHER-4,ZOMBIE-0.75 will cause the weapon to deal no damage to players, quadruple damage to Wither bosses and 75% damage to Zombies.

If set to true, the weapon will not drop when the player dies. When the player respawns, the weapon will still be in the inventory. Perfect for hard-to-earn weapons, as it makes it much more difficult for players lose them.

Clarification: This only prevents the weapon from dropping upon player death. You can drop it normally, place it in chests and so forth.

Killing mobs with this weapon will cause them to drop the item(s) specified. Bonus drops only apply to mobs, not players.

Uses: This ability can be used in conjunction with arena plugins such as MobArena for Nazi Zombies styled arenas, where zombies are killed for their gold ingots, which are then used to purchase better weapons through weapon stores.

Example: A weapon with Bonus_Drops: 264,98,352 will cause the victim to drop a diamond, a stone brick, and a bone upon death.

This is a particularly useful ability. You may have realized by now that hitting an entity will grant them invulnerability for a split second. This prevents them from getting hit too many times in one second. Setting this to true will reset the temporary invulnerability. If this node is false, weapons with a high rate of fire, or weapons like shotguns that fire more than one projectile, would not be as effective.

In a nutshell: This ability is a must-have for most firearms, especially for shotguns, which rely on having more than one projectile hit the enemy at the same time.

The amount of knockback the victim will experience upon being shot by the weapon. A value between 0-10 is recommended, where a value of 10 means... you shoot at an enemy, you blink, and the enemy is not longer visible. Negative values are accepted, and this will simply pull the victim towards you.

If true, a player holding this weapon upon landing will receive no fall damage.

If true, all vertical components of the weapon's recoil will be nullified. This will mean players will only ever be pushed backwards or forwards by the recoil, and never upwards or downwards.

If true, the player will receive the hurt effect whenever the weapon is used. A great effect for high-damage, single-shot weapons. However, using this node for fully automatic weapons with a high rate-of-fire may induce headaches.

If true, the recoil from the weapon will only launch the player upwards or downwards. Ideal for reaching great heights, but not so much for traveling, as your movement speed while airborne is incredibly slow.

Tip: For actual jets, do not use this node. Instead, simply give weapons a negative recoil.

This node causes projectiles to destroy the blocks they hit, except for blocks protected by CrackShot's built-in Region_Check module. Applies only to arrows, snowballs and eggs.

Format: <whitelist-blockID,(...)>

Provide true or false for whitelist. If whitelist is set to true, the projectile will destroy all blocks that you do not list. If whitelist is set to false, the projectile will only destroy the blocks that you list. You can specify as many block IDs that you want.

Examples:

• Break_Blocks: false-18,20,102 will cause the projectile to destroy all Leaves 18, Glass 20 and Glass Pane 102.
• Break_Blocks: true-1,12 will cause the projectile to destroy all blocks except for Stone 1 and Sand 12.

Secondary data values are supported - 160~4 would represent Stained Glass Pane (Yellow).

Flexibility: Blocks broken by this feature can be recorded and rolled back by external plugins (i.e. LogBlock, MobArena, Minigames).

Hit_Events:
    Enable: <true/false>
    Message_Shooter: <message>
    Message_Victim: <message>
    Sounds_Impact: <sound>,(...)
    Sounds_Shooter: <sound>,(...)
    Sounds_Victim: <sound>,(...)

Whether or not normal hits should display messages and/or sounds to the shooter and/or victim. Applies only to projectiles.

Note: Use this module appropriately, or it will result in the shooter/victim being spammed by messages or unsuitable noises. An example of an appropriate use of this node is for Semtex (sticky) grenades. When successfully hitting and "sticking" to an enemy, the shooter will be informed that an enemy has been successfully "stuck". I also like to play a soft "thoonk" noise to replicate hit markers, which indicate that an entity was hit.

The message the shooter will receive upon hitting an enemy.

The message the victim will receive upon being hit.

The sound(s) played at the projectile's position upon striking any surface, whether it be block or entity.

The sound(s) played at the shooter's position upon hitting an enemy.

The sound(s) played at the victim's position upon being hit.

Extras:
    One_Time_Use: <true/false>
    Disable_Underwater: <true/false>
    Make_Victim_Run_Commmand: <command>|(...)
    Make_Victim_Speak: <message>
    Run_Console_Command: <command>|(...)
    Run_Command:
        - <command>
        - (...)

Highly recommended for grenades and the like. If true, each time the weapon is used, one will be taken out of the player's hand. For ordinary firearms, setting this node to true will destroy the weapon after a single shot.

For remote-type and itembomb-type explosive devices, setting this node to true will:

• prevent the device from recharging its ammo after each detonation and
• destroy the device after its ammo reaches zero

Example: MrDerp is holding onto 6 Frag Grenades that have One_Time_Use: set to true. He right-clicks and throws one of the grenades. He now has 5 Frag Grenades left.

If true, and the player is submerged in water, the weapon will be disabled. However, if the player is not in water, the weapon will be functional. Please note that this does not break the weapon as soon as the player is underwater.

Makes the victim run a command upon getting hit. Do not provide the slash /, and surround your command(s) with quotes ". Reminder: special variables are supported.

Example: Make_Victim_Run_Commmand: "clear|me I'm getting out of here|quit" will make the victim execute /clear, /me I'm getting out of here and /quit upon being hit.

Makes the victim say something upon getting hit. Reminder: special variables are supported.

Example: Make_Victim_Speak: "Ow. <shooter> just shot me!" will make the victim say "Ow. (shooter's name) just shot me!" upon being hit.

Runs a console command when the weapon successfully damages a victim. Works in the same way as Make_Victim_Run_Commmand:, except this time the commands are run by the console. Reminder: special variables are supported.

Example: A weapon with Run_Console_Command: "ban <victim> You've been slapped with the Ban Hammer!" will ban anyone that gets shot by this weapon.

Runs a command when the weapon is shot. Do not provide the slash /, and always surround each command with quotes ". Commands that start with @ will be a console command. Only the <shooter> special variable is supported.

Example 1: Single Command

    Run_Command:
        - "me is running a command"

Whenever this weapon is shot, the shooter will execute /me is running a command.

Example 2: Single Console Command

    Run_Command:
        - "@kick <shooter>"

A player named Doge shoots this weapon. The console will execute kick Doge.

Example 3: Multiple Commands

    Run_Command:
        - "command_1"
        - "command_2"
        - "@console_command_1"
        - "@console_command_2"

Whenever this weapon is shot, the shooter will execute /command_1 and /command_2, and the console will execute console_command_1 and console_command_2. You can list as many commands as you want.