diego/survive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup, new alternating pulse mechanic.

Browse Source
This commit is contained in:
iegod
2024-11-05 06:49:34 -05:00
parent c234616fdf
commit 7608847727
2 changed files with 170 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

312
game.go
View File

@@ -1,7 +1,6 @@
package main
import (
"fmt"
"image/color"
"log"
"math"
@@ -47,12 +46,6 @@ func (g *Game) Initialize() {
g.collisionMask = ebiten.NewImage(screenWidth, screenHeight)
g.projectileMask = ebiten.NewImage(screenWidth, screenHeight)
/* single target
g.target = NewMover()
g.target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
*/
//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: 640 / 2, Y: 480 / 2}, 0., 5.))
g.explosion = NewExplosion()
g.explosion.SetOrigin(origin)
@@ -93,146 +86,7 @@ func (g *Game) Update() error {
g.projectiles = make(map[int]*Projectile)
g.initialized = true
} else {
if len(g.gamepadIDs) > 0 {
xaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickHorizontal)
yaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickVertical)
maxButton := ebiten.GamepadButton(ebiten.GamepadButtonCount(0))
for b := ebiten.GamepadButton(0); b < maxButton; b++ {
if ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton7) {
if !g.explosion.Active {
g.explosion.SetOrigin(g.mover.Pos)
g.explosion.Reset()
g.explosion.ToggleActivate()
}
}
}
if yaxis <= 0.09 && yaxis >= -0.09 {
yaxis = 0
}
if xaxis <= 0.09 && xaxis >= -0.09 {
xaxis = 0
}
inputangle := math.Atan2(yaxis, xaxis)
g.mover.SetAngle(inputangle)
}
/*
for id := range g.gamepadIDs {
xaxis := ebiten.StandardGamepadAxisValue(id, ebiten.StandardGamepadAxisRightStickHorizontal)
yaxis := ebiten.StandardGamepadAxisValue(id, ebiten.StandardGamepadAxisRightStickVertical)
inputangle := math.Atan2(yaxis, xaxis)
g.mover.SetAngle(inputangle)
}
*/
g.mover.Update()
g.explosion.Update()
for _, target := range g.targets {
if !target.Hit {
dx := g.mover.Pos.X - target.Pos.X
dy := g.mover.Pos.Y - target.Pos.Y
//dist := math.Sqrt(dx*dx + dy + dy)
angle := math.Atan2(dy, dx)
maxspeed := 3.
target.Pos.X += maxspeed * math.Cos(angle)
target.Pos.Y += maxspeed * math.Sin(angle)
}
target.Update()
}
for k, p := range g.projectiles {
//for i := 0; i < len(g.projectiles); i++ {
// g.projectiles[i].Update()
p.Update()
//if g.projectiles[i].Pos.X < 5 || g.projectiles[i].Pos.X > 635 || g.projectiles[i].Pos.Y < 5 || g.projectiles[i].Pos.Y > 475 {
if p.Pos.X < 5 || p.Pos.X > 635 || p.Pos.Y < 5 || p.Pos.Y > 475 {
p.Velocity = 0
delete(g.projectiles, k)
}
//compute collisions
for _, target := range g.targets {
//first, boundary check
if p.Pos.X >= target.Pos.X-MOVER_WIDTH/2 && p.Pos.X <= target.Pos.X+MOVER_WIDTH/2 && p.Pos.Y >= target.Pos.Y-MOVER_HEIGHT/2 && p.Pos.Y <= target.Pos.Y+MOVER_HEIGHT/2 && target.Action == MoverActionDamaged {
fmt.Println("potential collision")
g.collisionMask.Clear()
g.collisionMask.DrawImage(g.projectileMask, nil)
op := &ebiten.DrawImageOptions{}
op.GeoM.Reset()
op.Blend = ebiten.BlendSourceIn
op.GeoM.Translate(target.Pos.X-MOVER_WIDTH/2, target.Pos.Y-MOVER_HEIGHT/2)
g.collisionMask.DrawImage(target.Sprite, op)
//var pixels []byte = make([]byte, MOVER_WIDTH*MOVER_HEIGHT*4)
var pixels []byte = make([]byte, screenWidth*screenHeight*4)
g.collisionMask.ReadPixels(pixels)
for i := 0; i < len(pixels); i = i + 4 {
if pixels[i+3] != 0 {
fmt.Println("pixel collision")
delete(g.projectiles, k)
//target.ToggleColor()
target.SetHit()
//target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
target.Hit = true
break
}
}
}
}
}
//append new projectiles
if g.counter%14 == 0 {
//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.))
//g.projectiles = append(g.projectiles, NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.))
g.projectiles[g.counter] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.)
g.projectiles[g.counter+1] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.)
}
//add new target with increasing frequency
f := 40000 / (g.counter + 1)
if g.counter%f == 0 {
g.targets = append(g.targets, NewMover())
g.targets[len(g.targets)-1].SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
}
//handle explosion updates
if g.explosion.Active {
if g.explosion.Radius > math.Sqrt(640*640+480*480) {
g.explosion.ToggleActivate()
g.explosion.Reset()
}
//check collisions
for _, target := range g.targets {
dx := target.Pos.X - g.mover.Pos.X
dy := target.Pos.Y - g.mover.Pos.Y
r := math.Sqrt(dx*dx + dy*dy)
if r >= g.explosion.Radius-5 && r <= g.explosion.Radius+5 && target.Action <= MoverActionDefault {
//target.ToggleColor()
target.SetHit()
}
}
}
g.counter++
g.StepGame()
}
g.CleanupTargets()
@@ -298,11 +152,171 @@ func (g *Game) CleanupTargets() {
}
}
//then culling the last elements of the slice
if len(g.targets)-i > 0 {
/*if len(g.targets)-i > 0 {
fmt.Printf("Removing %d elements\n", len(g.targets)-i)
}
}*/
for j := i; j < len(g.targets); j++ {
g.targets[j] = nil
}
g.targets = g.targets[:i]
}
func (g *Game) StepGame() {
g.HandleInput()
g.mover.Update()
g.explosion.Update()
g.UpdateTargets()
g.UpdateProjectiles()
//append new projectiles
g.AppendProjectiles()
//add new target with increasing frequency
g.AddNewTargets()
//handle pulsewave updates
g.HandlePulseWaveUpdate()
g.counter++
}
func (g *Game) AddNewTargets() {
f := 40000 / (g.counter + 1)
if g.counter%f == 0 {
g.targets = append(g.targets, NewMover())
g.targets[len(g.targets)-1].SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
}
}
func (g *Game) HandlePulseWaveUpdate() {
if g.explosion.Active {
if g.explosion.Radius > math.Sqrt(640*640+480*480) {
g.explosion.ToggleActivate()
g.explosion.Reset()
g.ResetTargetTouches()
}
//check collisions
for _, target := range g.targets {
dx := target.Pos.X - g.mover.Pos.X
dy := target.Pos.Y - g.mover.Pos.Y
r := math.Sqrt(dx*dx + dy*dy)
if r >= g.explosion.Radius-5 && r <= g.explosion.Radius+5 && target.Action <= MoverActionDamaged && !target.Touched {
target.ToggleColor()
target.Touched = true
//target.SetHit()
}
}
}
}
func (g *Game) UpdateProjectiles() {
for k, p := range g.projectiles {
//for i := 0; i < len(g.projectiles); i++ {
// g.projectiles[i].Update()
p.Update()
//if g.projectiles[i].Pos.X < 5 || g.projectiles[i].Pos.X > 635 || g.projectiles[i].Pos.Y < 5 || g.projectiles[i].Pos.Y > 475 {
if p.Pos.X < 5 || p.Pos.X > 635 || p.Pos.Y < 5 || p.Pos.Y > 475 {
p.Velocity = 0
delete(g.projectiles, k)
}
//compute projectile collisions
for _, target := range g.targets {
//first, boundary check
if p.Pos.X >= target.Pos.X-MOVER_WIDTH/2 && p.Pos.X <= target.Pos.X+MOVER_WIDTH/2 && p.Pos.Y >= target.Pos.Y-MOVER_HEIGHT/2 && p.Pos.Y <= target.Pos.Y+MOVER_HEIGHT/2 && target.Action == MoverActionDamaged {
//fmt.Println("potential collision")
g.collisionMask.Clear()
g.collisionMask.DrawImage(g.projectileMask, nil)
op := &ebiten.DrawImageOptions{}
op.GeoM.Reset()
op.Blend = ebiten.BlendSourceIn
op.GeoM.Translate(target.Pos.X-MOVER_WIDTH/2, target.Pos.Y-MOVER_HEIGHT/2)
g.collisionMask.DrawImage(target.Sprite, op)
//var pixels []byte = make([]byte, MOVER_WIDTH*MOVER_HEIGHT*4)
var pixels []byte = make([]byte, screenWidth*screenHeight*4)
g.collisionMask.ReadPixels(pixels)
for i := 0; i < len(pixels); i = i + 4 {
if pixels[i+3] != 0 {
//fmt.Println("pixel collision")
delete(g.projectiles, k)
//target.ToggleColor()
target.SetHit()
//target.SetOrigin(Coordinates{X: rand.Float64() * 640, Y: rand.Float64() * 480})
target.Hit = true
break
}
}
}
}
}
}
func (g *Game) UpdateTargets() {
for _, target := range g.targets {
if !target.Hit {
dx := g.mover.Pos.X - target.Pos.X
dy := g.mover.Pos.Y - target.Pos.Y
angle := math.Atan2(dy, dx)
maxspeed := 3.
target.Pos.X += maxspeed * math.Cos(angle)
target.Pos.Y += maxspeed * math.Sin(angle)
}
target.Update()
}
}
func (g *Game) ResetTargetTouches() {
for _, t := range g.targets {
t.Touched = false
}
}
func (g *Game) AppendProjectiles() {
if g.counter%14 == 0 && ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton7) {
g.projectiles[g.counter] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle, 5.)
g.projectiles[g.counter+1] = NewProjectile(Coordinates{X: g.mover.Pos.X, Y: g.mover.Pos.Y}, g.mover.Angle+math.Pi, 5.)
}
}
func (g *Game) HandleInput() {
if len(g.gamepadIDs) > 0 {
maxButton := ebiten.GamepadButton(ebiten.GamepadButtonCount(0))
for b := ebiten.GamepadButton(0); b < maxButton; b++ {
if ebiten.IsGamepadButtonPressed(0, ebiten.GamepadButton11) {
if !g.explosion.Active {
g.explosion.SetOrigin(g.mover.Pos)
g.explosion.Reset()
g.explosion.ToggleActivate()
}
}
}
//account for controller sensitivity
xaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickHorizontal)
yaxis := ebiten.StandardGamepadAxisValue(0, ebiten.StandardGamepadAxisRightStickVertical)
if yaxis <= 0.09 && yaxis >= -0.09 {
yaxis = 0
}
if xaxis <= 0.09 && xaxis >= -0.09 {
xaxis = 0
}
inputangle := math.Atan2(yaxis, xaxis)
g.mover.SetAngle(inputangle)
}
}

8
mover.go
View File

@@ -68,6 +68,7 @@ type Mover struct {
rotating bool
Toggled bool
Hit bool
Touched bool
dyingcount int
}
@@ -164,5 +165,10 @@ func (m *Mover) SetHit() {
}
func (m *Mover) ToggleColor() {
m.Toggled = !m.Toggled
//m.Toggled = !m.Toggled
if m.Action == MoverActionDefault {
m.Action = MoverActionDamaged
} else if m.Action == MoverActionDamaged {
m.Action = MoverActionDefault
}
}