func (jm *JotaModule) NearestEnt(vs ...runtime.Val) runtime.Val {
	jm.dieOnTerminated()
	jm.engine.Pause()
	defer jm.engine.Unpause()
	g := jm.engine.GetState().(*game.Game)
	me := g.Ents[jm.myGid]
	if me == nil {
		return runtime.Nil
	}
	var closest game.Ent
	dist := 1e9
	for _, ent := range g.Ents {
		if ent == me {
			continue
		}
		if closest == nil {
			closest = ent
		} else if closest.Pos().Sub(me.Pos()).Mag2() < dist {
			dist = closest.Pos().Sub(me.Pos()).Mag2()
		}
	}
	if closest == nil {
		return runtime.Nil
	}
	return jm.newEnt(closest.Id())
}

func (pm *placeMine) Input(ent game.Ent, g *game.Game, pressAmt float64, trigger bool) {
	player := ent.(*game.PlayerEnt)
	if pressAmt == 0 {
		delete(player.Processes, pm.id)
		return
	}
	proc, ok := player.Processes[pm.id].(*multiDrain)
	if !ok {
		player.Processes[pm.id] = &multiDrain{Gid: player.Gid, Unit: game.Mana{300, 0, 0}}
		return
	}
	if trigger && proc.Stored > 1 {
		proc.Stored--
		heading := (linear.Vec2{1, 0}).Rotate(ent.Angle())
		pos := ent.Pos().Add(heading.Scale(100))
		g.MakeMine(pos, linear.Vec2{}, 100, 100, 100, 100)
	}
}

func (p *pull) Think(ent game.Ent, g *game.Game) {
	player := ent.(*game.PlayerEnt)
	proc, ok := player.Processes[p.id].(*multiDrain)
	if !ok {
		return
	}
	if p.trigger && p.draining && proc.Stored > 1 {
		proc.Stored -= 0.1
		if proc.Stored <= 1.0 {
			p.draining = false
		}
		for _, ent := range g.Ents {
			ray := ent.Pos().Sub(player.Pos())
			if ray.Mag2() < 0.1 {
				continue
			}
			target_angle := ray.Angle() - player.Angle()
			for target_angle < 0 {
				target_angle += math.Pi * 2
			}
			for target_angle > math.Pi*2 {
				target_angle -= math.Pi * 2
			}
			if target_angle > p.angle/2 && target_angle < math.Pi*2-p.angle/2 {
				continue
			}
			ray = player.Pos().Sub(ent.Pos())
			ray = ray.Norm()
			ent.ApplyForce(ray.Scale(-p.force))
			player.ApplyForce(ray.Scale(p.force).Scale(0.01))
		}
	}
}

func (f *fire) getFrontPos(ent game.Ent, g *game.Game) linear.Vec2 {
	r := rand.New(g.Rng)
	theta := r.Float64() * math.Pi * 2
	dist := math.Abs(r.NormFloat64() * f.deviance)
	if dist > f.deviance*4 {
		dist = f.deviance * 4
	}
	dist = dist + dist*math.Cos(theta)
	center := (linear.Vec2{f.distToCenter, 0}).Rotate(ent.Angle()).Add(ent.Pos())
	return (linear.Vec2{0, dist}).Rotate(ent.Angle() - math.Pi/2 + theta).Add(center)
}

func (a *asplode) Input(ent game.Ent, g *game.Game, pressAmt float64, trigger bool) {
	if trigger && !ent.Dead() {
		// Kill ent and put down explosion
		ent.Suicide()
		g.Processes = append(g.Processes, &asplosionProc{
			StartRadius:    a.startRadius,
			EndRadius:      a.endRadius,
			DurationThinks: a.durationThinks,
			Dps:            a.dps,
			Pos:            ent.Pos(),
		})
	}
}

func (f *lightning) Draw(ent game.Ent, g *game.Game) {
	if !f.draw {
		return
	}
	gl.Disable(gl.TEXTURE_2D)
	gl.Color4ub(255, 255, 255, 255)
	forward := (linear.Vec2{1, 0}).Rotate(ent.Angle()).Scale(100000.0)
	gl.Begin(gl.LINES)
	v := ent.Pos().Add(forward)
	gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y))
	v = ent.Pos().Sub(forward)
	gl.Vertex2d(gl.Double(v.X), gl.Double(v.Y))
	gl.End()
}