Version: v2.0.0+incompatible Latest Latest Go to latest
Published: Feb 7, 2018 License: Apache-2.0

## Documentation ¶

### Overview ¶

Package physics provides vector types and operations to perform math and simple physics on those types. It also provides rules for attaching entities to vectors.

### Constants ¶

View Source
```const (
// CUTOFF is used for rounding after floating point operations to
// zero out vector values that are sufficiently close to zero
CUTOFF = 0.001
)```

### Variables ¶

This section is empty.

### Functions ¶

#### func Push ¶

`func Push(a Pushes, b Pushable) error`

Push applies the force from the pushing object its target

### Types ¶

#### type Attachable ¶

```type Attachable interface {
Detach() Vector
Attach(Attachable, ...float64) Vector
AttachX(Attachable, float64) Vector
AttachY(Attachable, float64) Vector
Vec() Vector
}```

Attachable represents things that can be attached to Vectors

#### type ForceVector ¶

```type ForceVector struct {
Vector
Force *float64
}```

ForceVector is a vector that has some force and can operate on entites with mass

#### func DefaultForceVector ¶

`func DefaultForceVector(delta Vector, mass float64) ForceVector`

DefaultForceVector returns a force vector that converts the mass given into a force float

#### func NewForceVector ¶

`func NewForceVector(direction Vector, force float64) ForceVector`

NewForceVector returns a force vector

#### func (ForceVector) GetForce ¶

`func (f ForceVector) GetForce() ForceVector`

GetForce is a self-returning call

#### type Mass ¶

```type Mass struct {
// contains filtered or unexported fields
}```

A Mass can have forces applied against it

#### func (*Mass) Freeze ¶

`func (m *Mass) Freeze()`

Freeze changes a pushables mass such that it can no longer be pushed.

#### func (*Mass) GetMass ¶

`func (m *Mass) GetMass() float64`

GetMass returns the mass of an object

#### func (*Mass) SetMass ¶

`func (m *Mass) SetMass(inMass float64) error`

SetMass of an object

#### type Pushable ¶

```type Pushable interface {
GetDelta() Vector
GetMass() float64
}```

Pushable is implemented by anything that has mass and directional movement, and therefore can be pushed.

#### type Pushes ¶

```type Pushes interface {
GetForce() ForceVector
}```

A Pushes can push Pushable things through its associated ForceVector, or how hard the Pushable should move in a given direction

#### type Vector ¶

```type Vector struct {
// contains filtered or unexported fields
}```

A Vector is a two-dimensional point or vector used throughout oak to maintain functionality between packages.

#### func AngleVector ¶

`func AngleVector(angle float64) Vector`

AngleVector creates a unit vector by the cosine and sine of the given angle in degrees

#### func MaxVector ¶

`func MaxVector(a, b Vector) Vector`

MaxVector returns whichever vector has a greater magnitude

#### func NewVector ¶

`func NewVector(x, y float64) Vector`

NewVector returns a vector with the given x and y components

#### func NewVector32 ¶

`func NewVector32(x, y float32) Vector`

NewVector32 accepts float32s (and will cast them to float64s), to create a vector

#### func PtrVector ¶

`func PtrVector(x, y *float64) Vector`

PtrVector takes in pointers as opposed to float values-- these same pointers will be used in the returned vector and by attachments to that vector.

`func (v Vector) Add(vs ...Vector) Vector`

#### func (Vector) Angle ¶

`func (v Vector) Angle() float64`

Angle returns this vector as an angle in degrees

#### func (Vector) Attach ¶

`func (v Vector) Attach(a Attachable, offsets ...float64) Vector`

Attach takes in something for this vector to attach to and a set of offsets. The resulting combined vector with the offsets is then returned, and needs to be assigned to the calling vector.

#### func (Vector) AttachX ¶

`func (v Vector) AttachX(a Attachable, offX float64) Vector`

AttachX performs an attachment that only attaches on the X axis.

#### func (Vector) AttachY ¶

`func (v Vector) AttachY(a Attachable, offY float64) Vector`

AttachY performs an attachment that only attaches on the Y axis.

#### func (Vector) Copy ¶

`func (v Vector) Copy() Vector`

Copy copies a Vector

#### func (Vector) Detach ¶

`func (v Vector) Detach() Vector`

Detach returns a vector no longer attached to anything. The returned vector needs to be assigned to the caller for the caller to be replaced (vectors do not use pointer receivers)

#### func (Vector) Distance ¶

`func (v Vector) Distance(v2 Vector) float64`

Distance on two vectors returns the euclidean distance from v to v2

#### func (Vector) Dot ¶

`func (v Vector) Dot(v2 Vector) float64`

Dot returns the dot product of the vectors

#### func (Vector) GetForce ¶

`func (v Vector) GetForce() ForceVector`

GetForce on a non-force vector returns a zero-value for force

#### func (Vector) GetPos ¶

`func (v Vector) GetPos() (float64, float64)`

GetPos returns both v.X() and v.Y()

#### func (Vector) Magnitude ¶

`func (v Vector) Magnitude() float64`

Magnitude returns the magnitude of the combined components of a Vector

#### func (Vector) Normalize ¶

`func (v Vector) Normalize() Vector`

Normalize divides both components in a vector by the vector's magnitude

#### func (Vector) Rotate ¶

`func (v Vector) Rotate(fs ...float64) Vector`

Rotate takes in a set of angles and rotates v by their sum the input angles are assumed to be in degrees.

#### func (Vector) Scale ¶

`func (v Vector) Scale(fs ...float64) Vector`

Scale scales a vector by a set of floating points Scale(f1,f2,f3) is equivalent to Scale(f1*f2*f3)

#### func (Vector) SetPos ¶

`func (v Vector) SetPos(x, y float64) Vector`

SetPos is equivalent to NewVector(x,y)

#### func (Vector) SetX ¶

`func (v Vector) SetX(x float64) Vector`

SetX returns a vector with its x component set to x

#### func (Vector) SetY ¶

`func (v Vector) SetY(y float64) Vector`

SetY returns a vector with its y component set to y

#### func (Vector) ShiftX ¶

`func (v Vector) ShiftX(x float64) Vector`

ShiftX is equivalent to v.X() += x

#### func (Vector) ShiftY ¶

`func (v Vector) ShiftY(y float64) Vector`

ShiftY is equivalent to v.Y() += y

#### func (Vector) Sub ¶ added in v1.2.0

`func (v Vector) Sub(vs ...Vector) Vector`

Sub combines a set of vectors through subtraction

#### func (Vector) Vec ¶

`func (v Vector) Vec() Vector`

Vec returns a vector itself

#### func (Vector) X ¶

`func (v Vector) X() float64`

X returns this vector's x component

#### func (Vector) Xp ¶

`func (v Vector) Xp() *float64`

Xp returns the real pointer behind this vector's x component

#### func (Vector) Y ¶

`func (v Vector) Y() float64`

Y returns this vector's x component

#### func (Vector) Yp ¶

`func (v Vector) Yp() *float64`

Yp returns the real pointer behind this vector's y component

#### func (Vector) Zero ¶

`func (v Vector) Zero() Vector`

Zero is shorthand for NewVector(0,0), but uses the input vector