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()
}