pipes.go

// Copyright 2017 Google Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to writing, software distributed
// under the License is distributed on a "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied.
//
// See the License for the specific language governing permissions and
// limitations under the License.

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"

	"github.com/veandco/go-sdl2/img"
	"github.com/veandco/go-sdl2/sdl"
)

type pipes struct {
	mu sync.RWMutex

	texture *sdl.Texture
	speed   int32

	pipes []*pipe
}

func newPipes(r *sdl.Renderer) (*pipes, error) {
	texture, err := img.LoadTexture(r, "res/imgs/pipe.png")
	if err != nil {
		return nil, fmt.Errorf("could not load pipe image: %v", err)
	}

	ps := &pipes{
		texture: texture,
		speed:   2,
		pipes:   []*pipe{},
	}

	go func() {
		for {
			ps.mu.Lock()
			ps.pipes = append(ps.pipes, newPipe())
			if l := len(ps.pipes); l >= 2 {
				lastPipe := ps.pipes[l-1]
				secondLastPipe := ps.pipes[l-2]
				const margin = 5 * birdWidth
				lastPipe.x = secondLastPipe.x + margin
			}
			ps.mu.Unlock()
			time.Sleep(time.Second)
		}
	}()

	return ps, nil
}

func (ps *pipes) paint(r *sdl.Renderer) error {
	ps.mu.RLock()
	defer ps.mu.RUnlock()

	for _, p := range ps.pipes {
		if err := p.paint(r, ps.texture); err != nil {
			return err
		}
	}
	return nil
}

func (ps *pipes) touch(b *bird) {
	ps.mu.RLock()
	defer ps.mu.RUnlock()
	for _, p := range ps.pipes {
		p.touch(b)
	}
}

func (ps *pipes) restart() {
	ps.mu.Lock()
	defer ps.mu.Unlock()

	ps.pipes = nil
	time.Sleep(time.Second)
}

func (ps *pipes) update() {
	ps.mu.Lock()
	defer ps.mu.Unlock()

	var rem []*pipe
	for _, p := range ps.pipes {
		p.mu.Lock()
		p.x -= ps.speed
		p.mu.Unlock()
		if p.x+p.w > 0 {
			rem = append(rem, p)
		}
	}
	ps.pipes = rem
}

func (ps *pipes) destroy() {
	ps.mu.Lock()
	defer ps.mu.Unlock()

	ps.texture.Destroy()
}

func (ps *pipes) closestPipe() *pipe {
	ps.mu.Lock()
	defer ps.mu.Unlock()

	if len(ps.pipes) == 0 {
		return nil
	}
	for _, p := range ps.pipes {
		p.mu.Lock()
		x, h, w := p.x, p.h, p.w
		p.mu.Unlock()
		return &pipe{
			x: x,
			h: h,
			w: w,
		}
	}
	return nil
}

type pipe struct {
	mu sync.RWMutex

	x int32
	h int32
	w int32
}

func newPipe() *pipe {
	return &pipe{
		x: windowWidth,
		h: 100 + int32(rand.Intn(300)),
		w: 50,
	}
}

func (p *pipe) touch(b *bird) {
	p.mu.RLock()
	defer p.mu.RUnlock()
	b.touch(p)
}

func (p *pipe) paint(r *sdl.Renderer, texture *sdl.Texture) error {
	p.mu.RLock()
	defer p.mu.RUnlock()

	// top pipe
	{
		rect := &sdl.Rect{X: p.x, Y: 0, W: p.w, H: windowHeight - p.h - 3*birdHeight}
		flip := sdl.RendererFlip(sdl.FLIP_VERTICAL)
		if err := r.CopyEx(texture, nil, rect, 0, nil, flip); err != nil {
			return fmt.Errorf("could not copy background: %v", err)
		}
	}

	// bottom pipe
	{
		rect := &sdl.Rect{X: p.x, Y: windowHeight - p.h, W: p.w, H: p.h}
		flip := sdl.FLIP_NONE
		if err := r.CopyEx(texture, nil, rect, 0, nil, flip); err != nil {
			return fmt.Errorf("could not copy background: %v", err)
		}
	}

	return nil
}