twitchapon-anim

ebitest.go (4780B)

---

 package main
 
 import (
 	_ "bytes"
 	"errors"
 	"fmt"
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
 	"image/color"
 	_ "image/jpeg"
 	_ "image/png"
 	"io"
 	"log"
 	"math"
 	"math/rand"
 	"net/http"
 	"os"
 	"strconv"
 	"time"
 )
 
 const S_FRAMERATE = 60
 const S_SPEED = 200.0
 const S_TTL = 20
 
 var has_req bool = false
 
 var NumSprites int = 1
 var ScreenSize struct {
 	width, height int
 }
 
 // images initialized in init()
 var Images = make(map[string]*ebiten.Image)
 
 type Sprite struct {
 	img      *ebiten.Image
 	opt      ebiten.DrawImageOptions
 	x, y     float64
 	angle    float64
 	rotation float64
 	expires  int64
 }
 
 type Game struct {
 	inited    bool
 	sprites   []*Sprite
 	animation *TGifObject
 }
 
 var game *Game
 
 func (g *Game) Update() error {
 	if !g.inited {
 		fmt.Println("(Game::update()) calling Game::init()")
 		g.init()
 	}
 
 	if ebiten.IsKeyPressed(ebiten.KeyQ) || ebiten.IsKeyPressed(ebiten.KeyEscape) {
 		// @todo find out if it is possible to gracefully stop the game via ebiten structure
 		return errors.New("exit")
 	}
 
 	if ebiten.IsKeyPressed(ebiten.KeySpace) || has_req {
 		g.sprites = append(g.sprites, makeRandomSprite())
 		has_req = false
 	}
 
 	sprites_new := []*Sprite{}
 	for _, sprite := range g.sprites {
 		if sprite.expires > time.Now().Unix() {
 			sprites_new = append(sprites_new, sprite)
 		}
 	}
 
 	g.sprites = sprites_new
 	for _, sprite := range g.sprites {
 		err := sprite.Update()
 		if err != nil {
 			return err
 		}
 	}
 
 	_ = g.animation.Update()
 
 	return nil
 }
 
 func (sprite *Sprite) Update() error {
 	wInt, hInt := sprite.img.Size()
 	w, h := float64(wInt), float64(hInt)
 	fps := ebiten.CurrentFPS()
 	if fps == 0 {
 		fps = S_FRAMERATE
 	}
 
 	delta := S_SPEED / fps
 	dx := delta * math.Cos(sprite.angle)
 	dy := delta * math.Sin(sprite.angle)
 
 	x := sprite.x + dx
 	y := sprite.y + dy
 
 	scrW, scrH := float64(ScreenSize.width), float64(ScreenSize.height)
 
 	bounce := false
 	// bouncing off walls
 	if x+w >= scrW || x <= 0 {
 		sprite.angle = math.Pi*3 - sprite.angle
 		bounce = true
 	} else if y+h >= scrH || y <= 0 {
 		sprite.angle = math.Pi*2 - sprite.angle
 		bounce = true
 	}
 
 	if bounce {
 		dx = delta * math.Cos(sprite.angle)
 		dy = delta * math.Sin(sprite.angle)
 		x = sprite.x + dx
 		y = sprite.y + dy
 
 		if x+w >= scrW || x <= 0 {
 			sprite.x -= dx
 		}
 		if y+h >= scrH || y <= 0 {
 			sprite.y -= dy
 		}
 
 	} else {
 		sprite.x = x
 		sprite.y = y
 	}
 
 	// rotating image
 	sprite.rotation += math.Pi / 60.0
 
 	return nil
 }
 
 func (g *Game) Draw(screen *ebiten.Image) {
 	//defer g.ShowDebug(screen)
 
 	// background
 	screen.Fill(color.RGBA{0, 0xFF, 0, 0xFF})
 
 	for _, sprite := range g.sprites {
 		w, h := sprite.img.Size()
 		sprite.opt.GeoM.Reset()
 		sprite.opt.GeoM.Translate(-float64(w)/2, -float64(h)/2)
 		sprite.opt.GeoM.Rotate(sprite.rotation)
 		sprite.opt.GeoM.Translate(float64(w/2), float64(h/2))
 		sprite.opt.GeoM.Translate(sprite.x, sprite.y)
 		//sprite.opt.ColorM.Translate(0, 0, 0, -0.0003)
 		screen.DrawImage(sprite.img, &sprite.opt)
 	}
 
 	g.animation.Draw(screen)
 }
 
 func (g *Game) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
 	return ScreenSize.width, ScreenSize.height
 }
 
 func (g *Game) init() {
 	defer func() {
 		g.inited = true
 		fmt.Println("Game inited ok")
 	}()
 	fmt.Println("Game::init()")
 	rand.Seed(time.Now().UnixNano())
 
 	for i := 0; i < NumSprites; i++ {
 		g.sprites = append(g.sprites, makeRandomSprite())
 	}
 
 	var err error
 	g.animation, err = MakeGifObject("assets/terry1.gif")
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 
 func makeRandomSprite() *Sprite {
 	x := float64(ScreenSize.width) / 2.0
 	y := float64(ScreenSize.height) / 2.0
 	angle := rand.Float64() * math.Pi * 2.0
 	fmt.Printf("initial x, y, angle: %0.2f %0.2f %0.2f\n", x, y, angle)
 	return makeSprite("chikaiKnife.png", x, y, angle)
 }
 
 func main() {
 	if len(os.Args) > 1 {
 		NumSprites, _ = strconv.Atoi(os.Args[1])
 	}
 
 	game = &Game{}
 	ebiten.SetWindowSize(ScreenSize.width, ScreenSize.height)
 	ebiten.SetWindowTitle("Twitchapon Receiver Module")
 	ebiten.SetMaxTPS(S_FRAMERATE)
 	ebiten.SetRunnableOnUnfocused(true)
 
 	http.HandleFunc("/", handleHttpRequest)
 	go func() {
 		http.ListenAndServe("localhost:2345", nil)
 	}()
 
 	if err := ebiten.RunGame(game); err != nil {
 		log.Fatal(err)
 	}
 }
 
 func makeSprite(name string, x float64, y float64, angle float64) *Sprite {
 	return &Sprite{Images[name], ebiten.DrawImageOptions{}, x, y, angle, 0.0 /* rotation */, time.Now().Unix() + S_TTL /* expires */}
 }
 
 func (g *Game) ShowDebug(screen *ebiten.Image) {
 	msg := fmt.Sprintf("TPS: %0.2f\nFPS: %0.2f", ebiten.CurrentTPS(), ebiten.CurrentFPS())
 	ebitenutil.DebugPrint(screen, msg)
 }
 
 func handleHttpRequest(w http.ResponseWriter, req *http.Request) {
 	io.WriteString(w, "OK\n")
 	fmt.Println("http request ok")
 	has_req = true
 }