ChokePoint (jbwapi 2.1.0 API)

java.lang.Object
- bwem.ChokePoint

```
public final class ChokePoint
extends Object
```
ChokePoints are frontiers that BWEM automatically computes from Brood War's maps.
A ChokePoint represents (part of) the frontier between exactly 2 Areas. It has a form of line.
A ChokePoint doesn't contain any MiniTile: All the MiniTiles whose positions are returned by its Geometry() are just guaranteed to be part of one of the 2 Areas.
Among the MiniTiles of its Geometry, 3 particular ones called nodes can also be accessed using Pos(middle), Pos(end1) and Pos(end2).
ChokePoints play an important role in BWEM:
- they define accessibility between Areas.
- the Paths provided by BWMap::GetPath are made of ChokePoints.
Like Areas and Bases, the number and the addresses of ChokePoint instances remain unchanged.

Pseudo ChokePoints:
Some Neutrals can be detected as blocking Neutrals (Cf. Neutral::Blocking).
Because only ChokePoints can serve as frontiers between Areas, BWEM automatically creates a ChokePoint for each blocking Neutral (only one in the case of stacked blocking Neutral).
Such ChokePoints are called pseudo ChokePoints and they behave differently in several ways.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`ChokePoint.Node` ChokePoint::middle denotes the "middle" MiniTile of Geometry(), while ChokePoint::END_1 and ChokePoint::END_2 denote its "ends".

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`accessibleFrom(ChokePoint chokePoint)` Returns whether this ChokePoint is accessible from cp (through a walkable path). - Note: the relation is symmetric: this->accessibleFrom(cp) == cp->accessibleFrom(this) - Note: if this == cp, returns true. - Time complexity: O(1)
`int`	`distanceFrom(ChokePoint chokePoint)` If accessibleFrom(cp) == false, returns -1.
`boolean`	`equals(Object object)`
`Pair<Area,Area>`	`getAreas()` Returns the two areas of this ChokePoint.
`Neutral`	`getBlockingNeutral()` If !isPseudo(), returns nullptr.
`WalkPosition`	`getCenter()` Returns the center of this ChokePoint.
`List<WalkPosition>`	`getGeometry()` Returns the set of positions that defines the shape of this ChokePoint. - Note: none of these miniTiles actually belongs to this ChokePoint (a ChokePoint doesn't contain any MiniTile).
`WalkPosition`	`getNodePosition(ChokePoint.Node node)` Returns the position of one of the 3 nodes of this ChokePoint (Cf.
`WalkPosition`	`getNodePositionInArea(ChokePoint.Node node, Area area)` Pretty much the same as pos(n), except that the returned MiniTile position is guaranteed to be part of pArea.
`CPPath`	`getPathTo(ChokePoint cp)` Returns a list of getChokePoints, which is intended to be the shortest walking path from this ChokePoint to cp.
`int`	`hashCode()`
`boolean`	`isBlocked()` If !isPseudo(), returns false.
`boolean`	`isPseudo()` Tells whether this ChokePoint is a pseudo ChokePoint, i.e., it was created on top of a blocking Neutral.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - isPseudo
```
public boolean isPseudo()
```
    Tells whether this ChokePoint is a pseudo ChokePoint, i.e., it was created on top of a blocking Neutral.
  - getAreas
```
public Pair<Area,Area> getAreas()
```
    Returns the two areas of this ChokePoint.
  - getCenter
```
public WalkPosition getCenter()
```
    Returns the center of this ChokePoint.
  - getNodePosition
```
public WalkPosition getNodePosition(ChokePoint.Node node)
```
    Returns the position of one of the 3 nodes of this ChokePoint (Cf. node definition).
    - Note: the returned value is contained in geometry()
  - getNodePositionInArea
```
public WalkPosition getNodePositionInArea(ChokePoint.Node node,
                                          Area area)
```
    Pretty much the same as pos(n), except that the returned MiniTile position is guaranteed to be part of pArea. That is: BWMap::getArea(positionOfNodeInArea(n, pArea)) == pArea.
  - getGeometry
```
public List<WalkPosition> getGeometry()
```
    Returns the set of positions that defines the shape of this ChokePoint.
    - Note: none of these miniTiles actually belongs to this ChokePoint (a ChokePoint doesn't contain any MiniTile). They are however guaranteed to be part of one of the 2 areas.
    - Note: the returned set contains pos(middle), pos(END_1) and pos(END_2). If isPseudo(), returns {p} where p is the position of a walkable MiniTile near from blockingNeutral()->pos().
  - isBlocked
```
public boolean isBlocked()
```
    If !isPseudo(), returns false. Otherwise, returns whether this ChokePoint is considered blocked. Normally, a pseudo ChokePoint either remains blocked, or switches to not isBlocked when blockingNeutral() is destroyed and there is no remaining Neutral stacked with it. However, in the case where BWMap::automaticPathUpdate() == false, blocked() will always return true whatever blockingNeutral() returns. Cf. Area::AccessibleNeighbors().
  - getBlockingNeutral
```
public Neutral getBlockingNeutral()
```
    If !isPseudo(), returns nullptr. Otherwise, returns a pointer to the blocking Neutral on top of which this pseudo ChokePoint was created, unless this blocking Neutral has been destroyed. In this case, returns a pointer to the next blocking Neutral that was stacked at the same location, or nullptr if no such Neutral exists.
  - distanceFrom
```
public int distanceFrom(ChokePoint chokePoint)
```
    If accessibleFrom(cp) == false, returns -1. Otherwise, returns the ground distance in pixels between center() and cp->center(). - Note: if this == cp, returns 0.
    - Time complexity: O(1)
    - Note: Corresponds to the length in pixels of getPathTo(cp). So it suffers from the same lack of accuracy. In particular, the value returned tends to be slightly higher than expected when getPathTo(cp).size() is high.
  - accessibleFrom
```
public boolean accessibleFrom(ChokePoint chokePoint)
```
    Returns whether this ChokePoint is accessible from cp (through a walkable path).
    - Note: the relation is symmetric: this->accessibleFrom(cp) == cp->accessibleFrom(this)
    - Note: if this == cp, returns true.
    - Time complexity: O(1)
  - getPathTo
```
public CPPath getPathTo(ChokePoint cp)
```
    Returns a list of getChokePoints, which is intended to be the shortest walking path from this ChokePoint to cp. The path always starts with this ChokePoint and ends with cp, unless accessibleFrom(cp) == false. In this case, an empty list is returned.
    - Note: if this == cp, returns [cp].
    Time complexity: O(1)
    To get the length of the path returned in pixels, use distanceFrom(cp).
    - Note: all the possible Paths are precomputed during BWMap::initialize().
    The best one is then stored for each pair of getChokePoints. However, only the center of the getChokePoints is considered. As a consequence, the returned path may not be the shortest one.
  - equals
```
public boolean equals(Object object)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class ChokePoint

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isPseudo

getAreas

getCenter

getNodePosition

getNodePositionInArea

getGeometry

isBlocked

getBlockingNeutral

distanceFrom

accessibleFrom

getPathTo

equals

hashCode