Golang学习，通过教程。乒乓球，球在屏幕中央来回跳动。

我正在学习通过Youtube上的Go浏览Jack Mott的游戏。到目前为止，我一直在解决自己的问题，但这件事让我很挣扎。乒乓球游戏中的球在屏幕中央来回反弹。违规区域：

if int(ball.x) < int(rightPaddle.x)+rightPaddle.w/2 {
        if int(ball.y) > int(rightPaddle.y) - rightPaddle.h/2 && int(ball.y) < int(rightPaddle.y) +rightPaddle.h/2 {
            ball.xv = -ball.xv

        }
    }

如果int（ball.x）int（rightable.y）-rightable.h/2&&int（ball.y）

（来自//启动拨杆部分）

与左桨上面的线相同。当这被注释掉时，它工作得很好

有人能看一下吗？我想可能是球的功能，但它和视频是一样的。我已经通过视频在每一行上下移动，但似乎无法解决问题

package main

import (
"fmt"

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

const winWidth, winHeight int = 800, 600

type color struct {
    r, g, b byte
}

type pos struct {
    x,y float32
}


// BEGIN BALL

type ball struct {
    pos
    radius  int
    xv  float32
    yv  float32
    color   color
}
// DRAW BALL
func (ball *ball) draw(pixels []byte) {
    for y := -ball.radius; y < ball.radius; y++ {
        for x := -ball.radius; x < ball.radius; x++ {
            if x*x+y*y < ball.radius*ball.radius {
                setPixel(int(ball.x)+x, int(ball.y)+y, ball.color, pixels)
            }
        }
    }

}

func (ball *ball) update(leftPaddle *paddle, rightPaddle *paddle) {
    ball.x += ball.xv
    ball.y += ball.yv

    if int(ball.y)-ball.radius < 0 || int(ball.y)+ball.radius > winHeight {
        ball.yv = -ball.yv
    }
    if ball.x < 0 || int(ball.x) > winWidth {
        ball.x = 300
        ball.y = 300
    }
    if int(ball.x) < int(leftPaddle.x)+leftPaddle.w/2 {
        if int(ball.y) > int(leftPaddle.y) - leftPaddle.h/2 && int(ball.y) < int(leftPaddle.y) +leftPaddle.h/2 {
            ball.xv = -ball.xv

        }
    }

    if int(ball.x) < int(rightPaddle.x)+rightPaddle.w/2 {
        if int(ball.y) > int(rightPaddle.y) - rightPaddle.h/2 && int(ball.y) < int(rightPaddle.y) +rightPaddle.h/2 {
            ball.xv = -ball.xv

        }
    }
}

// END BALL
//********************************************************
// START PADDLE

type paddle struct {
    pos
    w       int
    h       int
    color   color

}

func (paddle *paddle) draw(pixels []byte) {
    startX := int(paddle.x) - paddle.w/2
    startY := int(paddle.y) - paddle.h/2

    for y := 0; y < paddle.h; y++ {
        for x := 0; x < paddle.w; x++ {
            setPixel(startX+x, startY+y, paddle.color, pixels)
        }
    }
}

func (paddle *paddle) update(keyState []uint8) {
    if keyState[sdl.SCANCODE_UP] != 0 {
        paddle.y--
    }
    if keyState[sdl.SCANCODE_DOWN] != 0 {
        paddle.y++
    }

}

// Player 2 Computer

func (paddle *paddle) aiUpdate(ball *ball) {
    paddle.y =  ball.y
}
// CLEAR PIXELS SO NO GHOSTING
func clear(pixels []byte) {
    for i := range pixels {
        pixels[i] = 0
    }
}

// END PADDLE

func setPixel(x, y int, c color, pixels []byte) {
    index := (y*winWidth + x) * 4

    if index < len(pixels)-4 && index >= 0 {
        pixels[index] = c.r
        pixels[index+1] = c.g
        pixels[index+2] = c.b
    }

}

func main() {

    // Added after EP06 to address macosx issues
    err := sdl.Init(sdl.INIT_EVERYTHING)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer sdl.Quit()

    window, err := sdl.CreateWindow("Testing SDL2", sdl.WINDOWPOS_UNDEFINED, sdl.WINDOWPOS_UNDEFINED,
        int32(winWidth), int32(winHeight), sdl.WINDOW_SHOWN)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer window.Destroy()

    renderer, err := sdl.CreateRenderer(window, -1, sdl.RENDERER_ACCELERATED)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer renderer.Destroy()

    tex, err := renderer.CreateTexture(sdl.PIXELFORMAT_ABGR8888, sdl.TEXTUREACCESS_STREAMING, int32(winWidth), int32(winHeight))
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tex.Destroy()

    pixels := make([]byte, winWidth*winHeight*4)

    tex.Update(nil, pixels, winWidth*4)
    renderer.Copy(tex, nil, nil)
    renderer.Present()

    player1 := paddle{pos{50,100},20, 100, color{255, 255, 255}}
    player2 := paddle{pos{float32(winWidth) - 50,100},20, 100, color{255, 255, 255}}
    ball := ball{pos{300, 300}, 20,4,4, color{255, 255, 255}}

    keyState := sdl.GetKeyboardState()

    // Changd after EP 06 to address MacOSX
    // OSX requires that you consume events for windows to open and work properly
    for {
        for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
            switch event.(type) {
            case *sdl.QuitEvent:
                return
            }
        }

        clear(pixels)

        player1.update(keyState)
        player2.aiUpdate(&ball)
        ball.update(&player1, &player2)

        player1.draw(pixels)
        player2.draw(pixels)
        ball.draw(pixels)


        tex.Update(nil, pixels, winWidth*4)
        renderer.Copy(tex, nil, nil)
        renderer.Present()

        sdl.Delay(16)
    }

}

包干管
进口(
“fmt”
“github.com/veandco/go-sdl2/sdl”
)
常量winWidth，winHeight int=800600
类型颜色结构{
r、 g，b字节
}
类型pos结构{
x、 y浮动32
}
//开球
类型球结构{
销售时点情报系统
半径整数
十五、第三十二条
yv浮动32
颜色
}
//抽签
func（球*球）绘制（像素[]字节）{
对于y:=-ball.radius；ywinHeight{
ball.yv=-ball.yv
}
如果ball.x<0 | | int（ball.x）>winWidth{
球x=300
球y=300
}
如果int（ball.x）int（leftball.y）-leftball.h/2&&int（ball.y）int（rightable.y）-rightable.h/2&&int（ball.y）=0{
像素[索引]=c.r
像素[索引+1]=c.g
像素[索引+2]=c.b
}
}
func main（）{
//在EP06之后添加，以解决macosx问题
err:=sdl.Init（sdl.Init\u所有内容）
如果错误！=零{
fmt.Println（错误）
返回
}
延迟sdl.Quit（）
window，err:=sdl.CreateWindow（“测试SDL2”，sdl.WINDOWPOS_未定义，sdl.WINDOWPOS_未定义，
int32（winWidth）、int32（winHeight）、sdl.窗口（如图所示）
如果错误！=零{
fmt.Println（错误）
返回
}
defer window.Destroy（）
渲染器，错误：=sdl.CreateRenderer（窗口，-1，sdl.renderer\u加速）
如果错误！=零{
fmt.Println（错误）
返回
}
defer renderer.Destroy（）
tex，err:=renderer.CreateTexture（sdl.PIXELFORMAT_abgr888，sdl.TEXTUREACCESS_STREAMING，int32（winWidth），int32（winHeight））
如果错误！=零{
fmt.Println（错误）
返回
}
推迟特克斯销毁（）
像素：=生成（[]字节，winWidth*winHeight*4）
tex.Update（零，像素，winWidth*4）
renderer.Copy（tex，nil，nil）
1.Present（）
player1:=桨{pos{50100}，20，100，颜色{255，255}
player2:=拨片{pos{float32（winWidth）-50100}，20100，颜色{255，255}
球：=球{pos{300300}，20,4,4，颜色{255,255,255}
keyState:=sdl.GetKeyboardState（）
//在EP 06之后更改，以解决MacOSX问题
//OSX要求您使用事件以使windows正常打开和工作
为了{
对于事件：=sdl.PollEvent（）；事件！=nil；事件=sdl.PollEvent（）{
开关事件。（类型）{
案例*sdl.QuitEvent：
返回
}
}
清除（像素）
player1.更新（键状态）
player2.aiUpdate（&ball）
ball.update（&player1和&player2）
player1.绘制（像素）
player2.绘制（像素）
ball.draw（像素）
tex.Update（零，像素，winWidth*4）
renderer.Copy（tex，nil，nil）
1.Present（）
sdl.延迟（16）
}
}

根据评论，您似乎需要

而不是

int（rightpaible.x）+rightpaible.w/2{

---

（）

看起来你需要的是

而不是

int（rightpeable.x）+rightpeable.w/2{

（来自）非常感谢。我对这些生命进行了多次检查，甚至运行了一个比较程序。谢谢你。不用担心，我已经添加了一个答案，以便其他人可以看到这个问题得到解决。