gg/collider.go

package gg

// Implementing the interface lets 
// the engine to work faster about
// collisions because it first checks
// if the the bigger collider that
// contains more complicated (accurate) structure
// do collide.
//type ColliderSimplifier interface {
	//ColliderSimplify() Triangle
//}

type CollisionType int
const (
	CollisionTypePhys CollisionType = iota
	CollisionTypeTrigger
)

// The structure contains collision information.
type Collision struct {
	Type CollisionType
	What, With Objecter
	// Points of Self contained in 
	Points Points
	Crosses []LineCross
}


// Implementing the interface lets the engine
// to determine if the object collides with anything.
// Mostly will use the Collide function with some
// inner structure field as first argument.
// The Collide method will be called on collisions.
type Collider interface {
	// Checks whether the object is collidable
	IsCollidable() bool
	Verticer
	Edger
	PointContainer
}
type Collidability struct {
	Collidable bool
}
func (c Collidability) IsCollidable() bool {
	return c.Collidable
}
type PointContainer interface {
	ContainedPoints(Points) Points
}
type Verticer interface {
	Vertices() Vertices
}
type Edger interface {
	Edges() Edges
}

// Implementing the type provides way
// to resolve collisions and other problems.
// The Resolve() is called right after the Update() of Updater.
type Resolver interface {
	IsResolvable() bool
	Resolve(c *Context)
	Collider
}
type Resolvability struct {
	Resolvable bool
}
func (r Resolvability) IsResolvable() bool {
	return r.Resolvable
}

func Collide(c1, c2 Collider) (Collision, bool) {
	vertices := c1.Vertices()
	es1, es2 := c1.Edges(), c2.Edges()
	crosses, doCross := es1.LineCrossWith(es2)
	pts := c2.ContainedPoints(vertices)
	return Collision{
		Points: pts,
		Crosses: crosses,
	}, len(pts) != 0 || doCross
}

func GetCollisions(c Collider, cs []Collider) []Collision {
	ret := []Collision{}
	for _, ic := range cs {
		if !ic.IsCollidable() || ic == c {
			continue
		}
	}
	return ret
}