Python 当我到达容纳对象的屏幕时，如何使用ScreenManager中的小部件进行移动？

当我移动到主窗口的水平屏幕时，我只想移动球或任何其他物体。。。 下面的下一个程序做了一些我想要的相关的事情，但是没有不同的屏幕。。。 这是代码

from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.properties import ObjectProperty, NumericProperty, ReferenceListProperty
from kivy.uix.widget import Widget
from kivy.vector import Vector
from kivy.graphics import Rotate, Rectangle, Ellipse, Color
from kivy.uix.gridlayout import GridLayout
from kivy.clock import Clock
from kivy.lang import Builder

class LoginWindow(Screen):
    def loginbtn(self):
        sm.current = "stage"


class StageWindow(Screen):
    def nextpage(self):
        sm.current = "main"
        game = MainWindow()
        game.serve_ball()
        Clock.schedule_interval(game.update, 1.0 / 60.0)
        return game

class MainWindow(Screen):
    ball = ObjectProperty(None)
    object = ObjectProperty(None)

    def serve_ball(self, vel=(4, 0)):
        self.ball.center = 40, 310
        self.ball.velocity = vel
        print('served')

    def update(self, dt):
        self.ball.move()
        self.object.deflect_ball(self.ball)
        if (self.ball.y < self.y):
            self.ball.velocity_y *= -1
            self.ball.velocity_y = 0
        if (self.ball.top > self.top):
            print('Done')

    def start(self):
        self.serve_ball()
        Clock.schedule_interval(self.update, 1.0 / 60.0)

class Object(Widget):
    def __init__(self, *args, **kwargs):
        Widget.__init__(self, *args, **kwargs)
        self.rect_pos_x = 500
        self.rect_pos_y = 300
        self.rect_pos = self.rect_pos_x, self.rect_pos_y
        self.rect_width = 200
        self.rect_height = 50
        self.rect_size = self.rect_width, self.rect_height
        self.rotate_origin_x = self.rect_pos_x + self.rect_width / 2
        self.rotate_origin_y = self.rect_pos_y + self.rect_height / 2
        self.rotate_origin = self.rotate_origin_x, self.rotate_origin_y
        self.angle = 135
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0, 255, 100))
            Rectangle(pos=self.rect_pos, size=self.rect_size)


    def rotate(self):
        self.canvas.clear()
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0, 255, 100))
            Rectangle(pos=self.rect_pos, size=self.rect_size)
        self.angle += 90
        print(self.angle)

    def deflect_ball(self, ball):
        if self.collide_widget(ball):
            vx, vy = ball.velocity
            if self.angle == 135:
                ball.velocity = Vector(-vx, vy).rotate(90)
            else:
                ball.velocity = Vector(-vx, vy).rotate(270)
            print('collided')

    def on_touch_up(self, touch):
        if self.collide_point(*touch.pos):
            self.rotate()
            print('hi')

class PongBall(Widget):
    velocity_x = NumericProperty(0)
    velocity_y = NumericProperty(0)
    velocity = ReferenceListProperty(velocity_x, velocity_y)

    def move(self):
        self.pos = Vector(*self.velocity) + self.pos

    def on_touch_up(self, touch):
        if self.collide_point(*touch.pos):
            print('clicked')

class WindowManager(ScreenManager):
    pass


kv = Builder.load_file("my.kv")
sm = WindowManager()


screens = [LoginWindow(name="login"), StageWindow(name="stage"), MainWindow(name="main")]
for screen in screens:
    sm.add_widget(screen)

sm.current = "login"

class GameApp(App):
    def build(self):
        return sm

if __name__ == "__main__":
    GameApp().run()

从kivy.app导入应用
从kivy.uix.label导入标签
从kivy.uix.screenmanager导入screenmanager，屏幕
从kivy.properties导入ObjectProperty、NumericProperty、ReferenceListProperty
从kivy.uix.widget导入widget
从kivy.vector导入向量
从kivy.graphics导入旋转、矩形、椭圆、颜色
从kivy.uix.gridlayout导入gridlayout
从kivy.clock导入时钟
从kivy.lang导入生成器
类登录窗口（屏幕）：
def loginbtn（自我）：
sm.current=“阶段”
课程阶段窗口（屏幕）：
def下一页（自我）：
sm.current=“main”
游戏=主窗口（）
比赛发球
时钟时间间隔（game.update，1.0/60.0）
回击赛
类主窗口（屏幕）：
ball=ObjectProperty（无）
对象=对象属性（无）
def发球（自我，水平=（4,0））：
self.ball.center=40310
self.ball.velocity=vel
打印（‘已送达’）
def更新（自我，dt）：
self.ball.move（）
自我。物体。偏转球（自我。球）
如果（self.ball.yself.top）：
打印（‘完成’）
def启动（自）：
自我发球
时钟计划间隔（自我更新，1.0/60.0）
类对象（小部件）：
定义初始化（self，*args，**kwargs）：
Widget.\uuuu初始化（self，*args，**kwargs）
self.rect\u pos\u x=500
self.rect_pos_y=300
self.rect\u pos=self.rect\u pos\u x，self.rect\u pos\y
self.rect_width=200
自校正高度=50
self.rect\u size=self.rect\u宽度，self.rect\u高度
self.rotate\u origin\u x=self.rect\u pos\u x+self.rect\u width/2
self.rotate\u origin\u y=self.rect\u pos\u y+self.rect\u height/2
self.rotate\u origin=self.rotate\u origin\u x，self.rotate\u origin\u y
自转角=135
使用self.canvas：
旋转（原点=self.Rotate\u原点，角度=self.angle）
颜色（rgb=（0255100））
矩形（pos=self.rect\u pos，size=self.rect\u size）
def旋转（自）：
self.canvas.clear（）
使用self.canvas：
旋转（原点=self.Rotate\u原点，角度=self.angle）
颜色（rgb=（0255100））
矩形（pos=self.rect\u pos，size=self.rect\u size）
自转角+=90
打印（自角度）
def偏转球（自身，球）：
如果self.collide_小部件（球）：
vx，vy=球的速度
如果self.angle==135：
球。速度=矢量（-vx，vy）。旋转（90）
其他：
球。速度=矢量（-vx，vy）。旋转（270）
打印（'冲突'）
def on_touch_up（自我，触摸）：
如果自碰撞点（*touch.pos）：
self.rotate（）
打印（'hi'）
类PongBall（小部件）：
速度x=数值属性（0）
速度_y=数值属性（0）
速度=ReferenceListProperty（速度x，速度y）
def移动（自我）：
self.pos=向量（*self.velocity）+self.pos
def on_touch_up（自我，触摸）：
如果自碰撞点（*touch.pos）：
打印（'单击'）
类WindowManager（屏幕管理器）：
通过
kv=Builder.load_文件（“my.kv”）
sm=WindowManager（）
屏幕=[LoginWindow（name=“login”）、StageWindow（name=“stage”）、主窗口（name=“main”）]
对于屏幕中的屏幕：
sm.add_小部件（屏幕）
sm.current=“登录”
类游戏应用程序（应用程序）：
def生成（自）：
返回sm
如果名称=“\uuuuu main\uuuuuuuu”：
GameApp（）.run（）

上面的Kivy文件是

WindowManager:
    StageWindow:
    LoginWindow:
    MainWindow:

<StageWindow>:
    name: "stage"
    FloatLayout:
        Label:
            pos_hint:{"x": 0.04, "y":0.3}
            size_hint:1.0, 1.0
            text: "Stage>>"

        Button:
            pos_hint:{"x":0,"y":0.05}
            size_hint: 0.2, 0.2
            text:"1"
            on_release:
                root.manager.transition.direction = "up"
                root.nextpage()
        Button:
            pos_hint:{"x":0.2,"y":0.05}
            size_hint: 0.2, 0.2
            text:"2"
            on_release:
                root.manager.transition.direction = "up"
                root.nextpage()
        Button:
            pos_hint:{"x":0.4,"y":0.05}
            size_hint: 0.2, 0.2
            text:"3"
            on_release:
                root.manager.transition.direction = "up"
                root.nextpage()
        Button:
            pos_hint:{"x":0.6,"y":0.05}
            size_hint: 0.2, 0.2
            text:"4"
            on_release:
            root.manager.transition.direction = "up"
                root.nextpage()
        Button:
            pos_hint:{"x":0.8,"y":0.05}
            size_hint: 0.2, 0.2
            text:"5"
            on_release:
                root.manager.direction = "down"
                root.nextpage()


<LoginWindow>:
    name: "login"


    FloatLayout:


        Button:
            pos_hint:{"x":0.2,"y":0.05}
            size_hint: 0.6, 0.2
            font_size: (root.width**2 + root.height**2) / 13**4
            text: "Play"
            on_release:
                root.manager.transition.direction = "left"
                root.loginbtn()


<MainWindow>:

    ball: pong_ball
    object: Object


    PongBall:
        id: pong_ball
        size: 50, 50
        canvas:
            Color:
                rgba: 0,0,1,1
            Ellipse:
                pos: self.pos
                size: self.size
        center: self.center


    Object:
        id: Object
        center: self.rotate_origin

WindowManager：
阶段窗口：
登录窗口：
主窗口：
:
名称：“舞台”
浮动布局：
标签：
pos_提示：{“x”：0.04，“y”：0.3}
大小提示：1.0，1.0
文字：“舞台>>”
按钮：
pos_提示：{“x”：0，“y”：0.05}
大小提示：0.2，0.2
案文：“1”
发布时：
root.manager.transition.direction=“向上”
root.nextpage（）
按钮：
pos_提示：{“x”：0.2，“y”：0.05}
大小提示：0.2，0.2
案文：“2”
发布时：
root.manager.transition.direction=“向上”
root.nextpage（）
按钮：
pos_提示：{“x”：0.4，“y”：0.05}
大小提示：0.2，0.2
案文：“3”
发布时：
root.manager.transition.direction=“向上”
root.nextpage（）
按钮：
pos_提示：{“x”：0.6，“y”：0.05}
大小提示：0.2，0.2
案文：“4”
发布时：
root.manager.transition.direction=“向上”
root.nextpage（）
按钮：
pos_提示：{“x”：0.8，“y”：0.05}
大小提示：0.2，0.2
案文：“5”
发布时：
root.manager.direction=“向下”
root.nextpage（）
:
名称：“登录”
浮动布局：
按钮：
pos_提示：{“x”：0.2，“y”：0.05}
尺寸提示：0.6,0.2
字体大小：（根.宽**2+根.高**2）/13**4
文字：“播放”
发布时：
root.manager.transition.direction=“左”
root.loginbtn（）
:
球：乒乓球
对象：对象
庞贝尔：
id:pong_ball
尺码：50，50
画布：
颜色：
rgba:0,0,1,1
椭圆：
pos:self.pos
大小：self.size
中心：自我中心
对象：
id:对象
中心：自旋转原点

这是一个显示我想做的事情，当我到达主窗口

from kivy.app import App
from kivy.uix.widget import Widget
from kivy.properties import NumericProperty, ReferenceListProperty, ObjectProperty
from kivy.vector import Vector
from kivy.clock import Clock
from random import randint
from kivy.lang import Builder
from kivy.graphics import Rotate, Color, Rectangle, Ellipse
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.screenmanager import ScreenManager, Screen

Builder.load_string('''

<PongGame>:
    name:"game"

    ball: pong_ball
    object: Object


    PongBall:
        id: pong_ball
        size: 50, 50 
        canvas:
            Color:
                rgba: 0,0,1,1
            Ellipse:
                pos: self.pos
                size: self.size 
        center: self.center


    Object:
        id: Object
        center: self.rotate_origin


''')

class Object(Widget):
    def __init__(self, *args, **kwargs):
        Widget.__init__(self, *args, **kwargs)
        self.rect_pos_x = 500
        self.rect_pos_y = 300
        self.rect_pos = self.rect_pos_x, self.rect_pos_y
        self.rect_width = 200
        self.rect_height = 50
        self.rect_size = self.rect_width, self.rect_height
        self.rotate_origin_x = self.rect_pos_x + self.rect_width / 2
        self.rotate_origin_y = self.rect_pos_y + self.rect_height / 2
        self.rotate_origin = self.rotate_origin_x, self.rotate_origin_y
        self.angle = 135
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0,197,68))
            Rectangle(pos=self.rect_pos, size=self.rect_size)


    def rotate(self):
        self.canvas.clear()
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0, 255, 100))
            Rectangle(pos=self.rect_pos, size=self.rect_size)
        self.angle += 90

    def deflect_ball(self, ball):
        if self.collide_widget(ball):
            vx, vy = ball.velocity
            if self.angle == 135 :
                ball.velocity = Vector(-vx, vy).rotate(90)
            else:
                ball.velocity = Vector(-vx, vy).rotate(270)
            print('collided')

    def on_touch_up(self, touch):
        if self.collide_point(*touch.pos):`enter code here`
            self.rotate()

class PongBall(Widget):
    velocity_x = NumericProperty(0)
    velocity_y = NumericProperty(0)
    velocity = ReferenceListProperty(velocity_x, velocity_y)


    def move(self):
        self.pos = Vector(*self.velocity) + self.pos



class PongGame(Widget):
    ball = ObjectProperty(None)

    object = ObjectProperty(None)

    def serve_ball(self, vel=(4, 0)):
        self.ball.center = 40, 310
        self.ball.velocity = vel
        print('hi')

    def update(self, dt):
        self.ball.move()
        self.object.deflect_ball(self.ball)

        if (self.ball.y < self.y):
            self.ball.velocity_y *=-1
            self.ball.velocity_y = 0
        if (self.ball.top > self.top):
            print('Done')


    def start(self):
        self.serve_ball()
        Clock.schedule_interval(self.update, 1.0 / 60.0)


class PongApp(App):
    def build(self):
        game = PongGame()
        game.serve_ball()
        Clock.schedule_interval(game.update, 1.0/60.0)
        return game


if __name__ == '__main__':
    PongApp().run()

来自kivy.a的

class MainWindow(Screen):
    ball = ObjectProperty(None)
    object = ObjectProperty(None)

    def serve_ball(self, vel=(4, 0)):
        self.ball.center = 40, 310
        self.ball.velocity = vel
        print('served')

    def update(self, dt):
        self.ball.move()
        self.object.deflect_ball(self.ball)
        if (self.ball.y < self.y):
            self.ball.velocity_y *= -1
            self.ball.velocity_y = 0
        if (self.ball.top > self.top):
            print('Done')

    def start(self):
        self.serve_ball()
        Clock.schedule_interval(self.update, 1.0 / 60.0)

    def on_enter(self):
        self.serve_ball()

from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.screenmanager import ScreenManager, Screen, CardTransition
from kivy.properties import ObjectProperty, NumericProperty, ReferenceListProperty
from kivy.uix.widget import Widget
from kivy.vector import Vector
from kivy.graphics import Rotate, Rectangle, Ellipse, Color
from kivy.uix.gridlayout import GridLayout
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.uix.progressbar import ProgressBar
from kivy.uix.popup import Popup
from kivy.uix.button import Button

Builder.load_string('''
<PongBall>:
    size: 50, 50
    canvas:
        Color:
            rgba: 0,0,1,1
        Ellipse:
            pos: self.pos
            size: self.size


<PongGame>:
    ball: pong_ball
    object: Object

    PongBall:
        id: pong_ball
        center: self.center

    Object:
        id: Object
        center: self.rotate_origin


<Manager>:
    id: screen_manager

    Screen:
        name:"P"
        FloatLayout:


            Button:
                pos_hint:{"x":0.2,"y":0.05}
                size_hint: 0.6, 0.2
                font_size: (root.width**2 + root.height**2) / 13**4
                text: "Play"
                on_release:
                    root.transition.direction = "up"        
                    root.current = "stage"

    Screen:
        name: 'Loading'
        MyWidget:                

    Screen:
        name: "stage"
        FloatLayout:
            Label:
                pos_hint:{"x": 0.04, "y":0.3}
                size_hint:1.0, 1.0
                text: "Stage>>"

            Button:
                pos_hint:{"x":0,"y":0.05}
                size_hint: 0.2, 0.2
                text:"1"
                on_release:
                    root.transition.direction = "right"
                    root.current= "Game";game.serve_ball()


    Screen:
        name: 'Game'
        PongGame:
            id: game

''')


class Object(Widget):
    def __init__(self, *args, **kwargs):
        Widget.__init__(self, *args, **kwargs)
        self.rect_pos_x = 500
        self.rect_pos_y = 300
        self.rect_pos = self.rect_pos_x, self.rect_pos_y
        self.rect_width = 200
        self.rect_height = 50
        self.rect_size = self.rect_width, self.rect_height
        self.rotate_origin_x = self.rect_pos_x + self.rect_width / 2
        self.rotate_origin_y = self.rect_pos_y + self.rect_height / 2
        self.rotate_origin = self.rotate_origin_x, self.rotate_origin_y
        self.angle = 135
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0,197,68))
            Rectangle(pos=self.rect_pos, size=self.rect_size)


    def rotate(self):
        self.canvas.clear()
        with self.canvas:
            Rotate(origin=self.rotate_origin, angle=self.angle)
            Color(rgb=(0, 255, 100))
            Rectangle(pos=self.rect_pos, size=self.rect_size)
        self.angle += 90

    def deflect_ball(self, ball):
        if self.collide_widget(ball):
            vx, vy = ball.velocity
            if self.angle == 135 :
                ball.velocity = Vector(-vx, vy).rotate(90)
            else:
                ball.velocity = Vector(-vx, vy).rotate(270)


    def on_touch_up(self, touch):
        if self.collide_point(*touch.pos):
            self.rotate()

class PongBall(Widget):
    velocity_x = NumericProperty(0)
    velocity_y = NumericProperty(0)
    velocity = ReferenceListProperty(velocity_x, velocity_y)

    def move(self):
        self.pos = Vector(*self.velocity) + self.pos


class PongGame(Widget):
    ball = ObjectProperty(None)
    object = ObjectProperty(None)

    def __init__(self, *args, **kwargs):
        super(PongGame, self).__init__(*args, **kwargs)
        Clock.schedule_interval(self.update, 1.0 / 60.0)


    def serve_ball(self, vel=(4, 0)):
        self.ball.center = 40, 310
        self.ball.velocity = vel

    def update(self, dt):
        self.ball.move()


        self.object.deflect_ball(self.ball)

        if (self.ball.y < self.y):
            self.ball.velocity_y *= -1
            self.ball.velocity_y = 0
        if (self.ball.top > self.top):




class Manager(ScreenManager):
    pass

sm = Manager()

class ScreensApp(App):
    def build(self):
        return sm

if __name__ == '__main__':
    ScreensApp().run()