WaterCombo

java.lang.Object
- com.projectkorra.projectkorra.ability.CoreAbility
- - com.projectkorra.projectkorra.ability.ElementalAbility
  - - com.projectkorra.projectkorra.ability.WaterAbility
    - - com.projectkorra.projectkorra.ability.IceAbility
      - com.projectkorra.projectkorra.waterbending.WaterCombo

All Implemented Interfaces:

Ability, ComboAbility, SubAbility

Direct Known Subclasses:

WaterCombo.IceBullet, WaterCombo.IceWave
```
public class WaterCombo
extends IceAbility
implements ComboAbility
```

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class WaterCombo.AbilityState

class WaterCombo.IceBullet

class WaterCombo.IceWave

Nested Classes
Modifier and Type	Class and Description
`static class`	`WaterCombo.AbilityState`
`class`	`WaterCombo.IceBullet`
`class`	`WaterCombo.IceWave`

Constructor Summary

Constructors
Constructor and Description

WaterCombo(org.bukkit.entity.Player player, java.lang.String name)

Constructors
Constructor and Description
`WaterCombo(org.bukkit.entity.Player player, java.lang.String name)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`canThaw(org.bukkit.block.Block block)`
`void`	`createBlock(org.bukkit.block.Block block, org.bukkit.Material mat)`
`void`	`createBlock(org.bukkit.block.Block block, org.bukkit.Material mat, byte data)`
`java.lang.Object`	`createNewComboInstance(org.bukkit.entity.Player player)` Creates a new instance of the combo from a specific player.
`void`	`drawWaterCircle(org.bukkit.Location loc, double theta, double increment, double radius)`
`void`	`drawWaterCircle(org.bukkit.Location loc, double theta, double increment, double radius, org.bukkit.Material mat, byte data)`
`java.util.concurrent.ConcurrentHashMap<org.bukkit.block.Block,TempBlock>`	`getAffectedBlocks()`
`double`	`getAnimationSpeed()`
`java.util.ArrayList<ComboManager.AbilityInformation>`	`getCombination()` Returns the list of abilities which constitute the combo.
`long`	`getCooldown()`
`double`	`getDamage()`
`org.bukkit.util.Vector`	`getDirection()`
`static java.util.concurrent.ConcurrentHashMap<org.bukkit.block.Block,TempBlock>`	`getFrozenBlocks()`
`java.lang.String`	`getInstructions()` Accessor Method to get the instructions for using this combo.
`double`	`getKnockback()`
`int`	`getLeftClicks()`
`org.bukkit.Location`	`getLocation()` Specifies the Location of the ability, which may be slightly inaccurate depending on the Ability implementation.
`double`	`getMaxShots()`
`java.lang.String`	`getName()` The name of the ability is used for commands such as /bending display and /bending help.
`org.bukkit.Location`	`getOrigin()`
`double`	`getRadius()`
`double`	`getRange()`
`int`	`getRightClicks()`
`double`	`getShootTime()`
`double`	`getShots()`
`double`	`getSpeed()`
`WaterCombo.AbilityState`	`getState()`
`java.util.ArrayList<org.bukkit.scheduler.BukkitRunnable>`	`getTasks()`
`long`	`getTime()`
`static java.util.ArrayList<WaterCombo>`	`getWaterCombo(org.bukkit.entity.Player player, java.lang.String ability)`
`WaterSourceGrabber`	`getWaterGrabber()`
`boolean`	`isHarmlessAbility()` Determines if this ability is considered harmless against other players.
`boolean`	`isHiddenAbility()` A hidden ability is an ability that should not be shown by commands such as /bending display and /bending help.
`boolean`	`isSneakAbility()` Determines if this ability uses the `PlayerToggleSneakEvent` as a controlling mechanism.
`void`	`manageShots()`
`void`	`progress()` Causes the ability to be updated.
`void`	`remove()` Causes this CoreAbility instance to be removed, and `Ability.progress()` will no longer be called every tick.
`void`	`revertBlocks()`
`void`	`setAnimationSpeed(double animationSpeed)`
`void`	`setCooldown(long cooldown)`
`void`	`setDamage(double damage)`
`void`	`setDirection(org.bukkit.util.Vector direction)`
`void`	`setKnockback(double knockback)`
`void`	`setLeftClicks(int leftClicks)`
`void`	`setLocation(org.bukkit.Location location)`
`void`	`setMaxShots(double maxShots)`
`void`	`setName(java.lang.String name)`
`void`	`setOrigin(org.bukkit.Location origin)`
`void`	`setRadius(double radius)`
`void`	`setRange(double range)`
`void`	`setRightClicks(int rightClicks)`
`void`	`setShootTime(double shootTime)`
`void`	`setShots(double shots)`
`void`	`setSpeed(double speed)`
`void`	`setState(WaterCombo.AbilityState state)`
`void`	`setTime(long time)`
`void`	`setWaterGrabber(WaterSourceGrabber waterGrabber)`
`static void`	`thaw(org.bukkit.block.Block block)`

Methods inherited from class com.projectkorra.projectkorra.ability.IceAbility
getElement, getParentAbility

Methods inherited from class com.projectkorra.projectkorra.ability.ElementalAbility
getTransparentMaterial, getTransparentMaterialSet, isDay, isEarth, isEarth, isFullMoon, isIce, isIce, isLava, isLava, isLunarEclipse, isMeltable, isMetal, isMetal, isMetalBlock, isNegativeEffect, isNeutralEffect, isNight, isPlant, isPlant, isPositiveEffect, isSand, isSand, isSolarEclipse, isSozinsComet, isTransparent, isTransparent, isTransparent, isUndead, isWater, isWater

Methods inherited from class com.projectkorra.projectkorra.ability.CoreAbility
getAbilities, getAbilities, getAbilities, getAbilitiesByElement, getAbility, getAbility, getBendingPlayer, getConfig, getDebugString, getDescription, getId, getLanguageConfig, getPlayer, getPlayers, getStartTime, hasAbility, isEnabled, isRemoved, isStarted, progressAll, registerAbilities, registerAddonAbilities, registerPluginAbilities, removeAll, start

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - WaterCombo
```
public WaterCombo(org.bukkit.entity.Player player,
                  java.lang.String name)
```
- Method Detail
  - createBlock
```
public void createBlock(org.bukkit.block.Block block,
                        org.bukkit.Material mat)
```
  - createBlock
```
public void createBlock(org.bukkit.block.Block block,
                        org.bukkit.Material mat,
                        byte data)
```
  - drawWaterCircle
```
public void drawWaterCircle(org.bukkit.Location loc,
                            double theta,
                            double increment,
                            double radius)
```
  - drawWaterCircle
```
public void drawWaterCircle(org.bukkit.Location loc,
                            double theta,
                            double increment,
                            double radius,
                            org.bukkit.Material mat,
                            byte data)
```
  - manageShots
```
public void manageShots()
```
  - progress
```
public void progress()
```
    Description copied from interface: Ability
    
    Causes the ability to be updated.
    
    Specified by:
    
    progress in interface Ability
  - remove
```
public void remove()
```
    Description copied from class: CoreAbility
    
    Causes this CoreAbility instance to be removed, and Ability.progress() will no longer be called every tick. If this method is overridden then the new method must call super.remove(). Causes the ability to be removed from existence.
    
    Specified by:
    
    remove in interface Ability
    
    Overrides:
    
    remove in class CoreAbility
    
    See Also:
    
    CoreAbility.isRemoved()
  - revertBlocks
```
public void revertBlocks()
```
  - canThaw
```
public static boolean canThaw(org.bukkit.block.Block block)
```
  - getWaterCombo
```
public static java.util.ArrayList<WaterCombo> getWaterCombo(org.bukkit.entity.Player player,
                                                            java.lang.String ability)
```
  - thaw
```
public static void thaw(org.bukkit.block.Block block)
```
  - getName
```
public java.lang.String getName()
```
    Description copied from interface: Ability
    
    The name of the ability is used for commands such as /bending display and /bending help. The name is also used for determining the tag for cooldowns BendingPlayer.addCooldown(Ability), therefore if two abilities have the same name they will also share cooldowns. If two classes share the same name (SurgeWall/SurgeWave) but need to have independent cooldowns, then BendingPlayer.addCooldown(String, long) should be called explicitly.
    
    Specified by:
    
    getName in interface Ability
    
    Returns:
    
    Returns the name of the ability
  - getLocation
```
public org.bukkit.Location getLocation()
```
    Description copied from interface: Ability
    
    Specifies the Location of the ability, which may be slightly inaccurate depending on the Ability implementation. For example, a TorrentWave could not be fully specified by a single location, while it is possible for an EarthBlast. The location is useful for making sure that the player is currently in the same world as the ability.
    
    Specified by:
    
    getLocation in interface Ability
    
    Returns:
    
    the location of the Ability
    
    See Also:
    
    BendingPlayer.canBend(CoreAbility)
  - getCooldown
```
public long getCooldown()
```
    Specified by:
    
    getCooldown in interface Ability
    
    Returns:
    
    the cooldown for the ability
  - isHiddenAbility
```
public boolean isHiddenAbility()
```
    Description copied from interface: Ability
    
    A hidden ability is an ability that should not be shown by commands such as /bending display and /bending help. For example: Combos, MultiAbility sub abilities, and helper abilities.
    
    Specified by:
    
    isHiddenAbility in interface Ability
    
    Overrides:
    
    isHiddenAbility in class CoreAbility
    
    Returns:
    
    true if the ability should not be displayed to the players
  - isSneakAbility
```
public boolean isSneakAbility()
```
    Description copied from interface: Ability
    
    Determines if this ability uses the PlayerToggleSneakEvent as a controlling mechanism. Currently WaterPassive will not work while the player has a sneak ability bound.
    
    Specified by:
    
    isSneakAbility in interface Ability
    
    Returns:
    
    true if the ability uses sneak as a controlling mechanism
  - isHarmlessAbility
```
public boolean isHarmlessAbility()
```
    Description copied from interface: Ability
    
    Determines if this ability is considered harmless against other players. A harmless ability cannot manipulate another player. For example: AirPassive, WaterSpout, AirSpout, and FireJet.
    
    Specified by:
    
    isHarmlessAbility in interface Ability
    
    Returns:
    
    true if the ability is harmless and should be allowed in both PvP and non-PvP zones
  - getInstructions
```
public java.lang.String getInstructions()
```
    Description copied from interface: ComboAbility
    
    Accessor Method to get the instructions for using this combo.
    
    Specified by:
    
    getInstructions in interface ComboAbility
    
    Returns:
    
    The steps for the combo.
  - createNewComboInstance
```
public java.lang.Object createNewComboInstance(org.bukkit.entity.Player player)
```
    Description copied from interface: ComboAbility
    
    Creates a new instance of the combo from a specific player. ProjectKorra's ComboModuleManager will use this method once the combo steps have been used by the player.
    
    Specified by:
    
    createNewComboInstance in interface ComboAbility
    
    Parameters:
    
    player - The player using the combo.
    
    Returns:
    
    A new instance of the ability.
  - getCombination
```
public java.util.ArrayList<ComboManager.AbilityInformation> getCombination()
```
    Description copied from interface: ComboAbility
    
    Returns the list of abilities which constitute the combo.
    
    Specified by:
    
    getCombination in interface ComboAbility
    
    Returns:
    
    An ArrayList containing the combo's steps.
  - getLeftClicks
```
public int getLeftClicks()
```
  - setLeftClicks
```
public void setLeftClicks(int leftClicks)
```
  - getRightClicks
```
public int getRightClicks()
```
  - setRightClicks
```
public void setRightClicks(int rightClicks)
```
  - getDamage
```
public double getDamage()
```
  - setDamage
```
public void setDamage(double damage)
```
  - getSpeed
```
public double getSpeed()
```
  - setSpeed
```
public void setSpeed(double speed)
```
  - getRange
```
public double getRange()
```
  - setRange
```
public void setRange(double range)
```
  - getKnockback
```
public double getKnockback()
```
  - setKnockback
```
public void setKnockback(double knockback)
```
  - getRadius
```
public double getRadius()
```
  - setRadius
```
public void setRadius(double radius)
```
  - getShootTime
```
public double getShootTime()
```
  - setShootTime
```
public void setShootTime(double shootTime)
```
  - getShots
```
public double getShots()
```
  - setShots
```
public void setShots(double shots)
```
  - getMaxShots
```
public double getMaxShots()
```
  - setMaxShots
```
public void setMaxShots(double maxShots)
```
  - getAnimationSpeed
```
public double getAnimationSpeed()
```
  - setAnimationSpeed
```
public void setAnimationSpeed(double animationSpeed)
```
  - getTime
```
public long getTime()
```
  - setTime
```
public void setTime(long time)
```
  - getState
```
public WaterCombo.AbilityState getState()
```
  - setState
```
public void setState(WaterCombo.AbilityState state)
```
  - getOrigin
```
public org.bukkit.Location getOrigin()
```
  - setOrigin
```
public void setOrigin(org.bukkit.Location origin)
```
  - getDirection
```
public org.bukkit.util.Vector getDirection()
```
  - setDirection
```
public void setDirection(org.bukkit.util.Vector direction)
```
  - getWaterGrabber
```
public WaterSourceGrabber getWaterGrabber()
```
  - setWaterGrabber
```
public void setWaterGrabber(WaterSourceGrabber waterGrabber)
```
  - getTasks
```
public java.util.ArrayList<org.bukkit.scheduler.BukkitRunnable> getTasks()
```
  - getFrozenBlocks
```
public static java.util.concurrent.ConcurrentHashMap<org.bukkit.block.Block,TempBlock> getFrozenBlocks()
```
  - getAffectedBlocks
```
public java.util.concurrent.ConcurrentHashMap<org.bukkit.block.Block,TempBlock> getAffectedBlocks()
```
  - setCooldown
```
public void setCooldown(long cooldown)
```
  - setName
```
public void setName(java.lang.String name)
```
  - setLocation
```
public void setLocation(org.bukkit.Location location)
```

Class WaterCombo

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class com.projectkorra.projectkorra.ability.IceAbility

Methods inherited from class com.projectkorra.projectkorra.ability.WaterAbility

Methods inherited from class com.projectkorra.projectkorra.ability.ElementalAbility

Methods inherited from class com.projectkorra.projectkorra.ability.CoreAbility

Methods inherited from class java.lang.Object

Constructor Detail

WaterCombo

Method Detail

createBlock

createBlock

drawWaterCircle

drawWaterCircle

manageShots

progress

remove

revertBlocks

canThaw

getWaterCombo

thaw

getName

getLocation

getCooldown

isHiddenAbility

isSneakAbility

isHarmlessAbility

getInstructions

createNewComboInstance

getCombination

getLeftClicks

setLeftClicks

getRightClicks

setRightClicks

getDamage

setDamage

getSpeed

setSpeed

getRange

setRange

getKnockback

setKnockback

getRadius

setRadius

getShootTime

setShootTime

getShots

setShots

getMaxShots

setMaxShots

getAnimationSpeed

setAnimationSpeed

getTime

setTime

getState

setState

getOrigin

setOrigin

getDirection

setDirection

getWaterGrabber

setWaterGrabber

getTasks

getFrozenBlocks

getAffectedBlocks

setCooldown

setName

setLocation