
from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from math import pi
from direct.actor.Actor import Actor
from direct.interval.IntervalGlobal import Sequence
from panda3d.core import Point3, KeyboardButton, CollisionBox, CollisionSphere, CollisionNode, CollisionTraverser, \
    CollisionHandlerQueue

from panda3d.core import Vec3


class MyApp(ShowBase):
    def __init__(self):
        # -------------ЧТобы мы могли с движком
        ShowBase.__init__(self)  # Python брат , мы теперь иммед доступ к Panda3D
    #     # ----------------------------------------------------------------------

        self.char = self.loader.loadModel("Models_2/i.obj")  # loader.loadModel Загружают
        self.char.reparentTo(self.render)

        self.char.setScale(1)
        self.char.setPos(-1.56, -28, 1)
        self.char.setHpr(180, 90, 0)

        self.lays = self.loader.loadModel("Models_2/lays.obj")  # loader.loadModel Загружают
        self.lays.reparentTo(self.render)

        self.lays.setScale(2)
        self.lays.setPos(-1.56, -10, 1.5)
        self.lays.setHpr(180, 90, 180)

        self.world = self.loader.loadModel("Models_2/world.obj")  # loader.loadModel Загружают
        self.world.reparentTo(self.render)

        self.world.setScale(15)
        self.world.setPos(0, 0, 0)
        self.world.setHpr(180, 90, 180)

        self.english = self.loader.loadModel("Models_2/english.obj")  # loader.loadModel Загружают
        self.english.reparentTo(self.render)

        self.english.setScale(3)
        self.english.setPos(-4, 14, 1)
        self.english.setHpr(180, 90, 180)

        self.literature = self.loader.loadModel("Models_2/literature.obj")  # loader.loadModel Загружают
        self.literature.reparentTo(self.render)

        self.literature.setScale(3)
        self.literature.setPos(-10, 14, 1)
        self.literature.setHpr(180, 90, 180)

        self.math = self.loader.loadModel("Models_2/math.obj")  # loader.loadModel Загружают
        self.math.reparentTo(self.render)

        self.math.setScale(3)
        self.math.setPos(3, 14, 1)
        self.math.setHpr(180, 90, 180)

        self.okruxayxnn = self.loader.loadModel("Models_2/okruxayxnn.obj")  # loader.loadModel Загружают
        self.okruxayxnn.reparentTo(self.render)

        self.okruxayxnn.setScale(3)
        self.okruxayxnn.setPos(3, 7, 1)
        self.okruxayxnn.setHpr(180, 90, 180)

        self.orkce = self.loader.loadModel("Models_2/orkce.obj")  # loader.loadModel Загружают
        self.orkce.reparentTo(self.render)

        self.orkce.setScale(3)
        self.orkce.setPos(-10, 0, 1)
        self.orkce.setHpr(180, 90, 180)

        self.russuan = self.loader.loadModel("Models_2/russuan.obj")  # loader.loadModel Загружают
        self.russuan.reparentTo(self.render)

        self.russuan.setScale(3)
        self.russuan.setPos(-4, -7, 1)
        self.russuan.setHpr(180, 90, 180)

        self.school = self.loader.loadModel("Models_2/school.obj")  # loader.loadModel Загружают
        self.school.reparentTo(self.render)

        self.school.setScale(4)
        self.school.setPos(3, -7, 1)
        self.school.setHpr(180, 90, 180)


        self.char.setPos(-1.56, -28, 1)
        self.x = 0
        self.y = -30
        self.z = 20
        self.keyMap = {
          "space": False,
          "left": False,
          "right": False
        }


        self.accept("space", self.updateKey, ["space", True])
        self.accept("space-up", self.updateKey, ["space", False])
        self.accept('a', self.updateKey, ["left", True])
        self.accept('a-up', self.updateKey, ["left", False])
        self.accept('d', self.updateKey, ["right", True])
        self.accept('d-up', self.updateKey, ["right", False])


        self.taskMgr.add(self.lalala, "update")
        self.taskMgr.add(self.update, "update")

        self.camera.setPos(self.char.getX(), self.char.getY() - 15, self.char.getZ() + 20)
        self.camera.lookAt(self.char)
    def updateKey(self,key,status):
        self.keyMap[key] = status

    def update(self, task):
        if self.keyMap["space"]:
            self.char.setPos(self.char.getPos() + Vec3(0, 0, 4))
        if self.keyMap["left"]:
            self.char.setPos(self.char.getPos() + Vec3( -1, 0, 0))
        if self.keyMap["right"]:
            self.char.setPos(self.char.getPos() + Vec3(1, 0, 0))
        return Task.cont
    def lalala(self, task):
        #self.camera.setPos(self.char.getX(), self.char.getY() - 30, self.char.getZ() + 10)
        #self.camera.lookAt(self.char)
        return Task.cont
    #
    #     ############################################################################################
    #     # Колизия - соприосновения
    #     # Сфера
    #     # х y z радиус
    #     cs = CollisionSphere(0, 0, 0, 5000)
    #     box = CollisionBox(20, 20, 20, 500)
    #     cnodepath2 = self.PandaActor.attachNewNode(CollisionNode('Oleg'))
    #     cnodepath = self.PandaActor.attachNewNode(CollisionNode('Egor'))
    #
    #     cnodepath2.node().addSolid(box)  # колизия добавляет в панду бокс
    #
    #     cnodepath2.show()
    #
    #     cnodepath.node().addSolid(cs)  # колизия добавляет в панду сферу
    #     cnodepath.show()
    #     ###############################################################################################
    #     # Обработка столкновений
    #     levelCollider = self.level.attachNewNode(CollisionNode('LevelCollider'))  # невидимая коробка для панды
    #     levelCollider.node().addSolid(
    #         CollisionBox((-500, -500, 0), (500, 500, 10)))  # раземр коробочки (типо растянули)
    #
    #     levelCollider.show()
    #
    #     # Включим обработчик столкновения
    #     self.cTrav = CollisionTraverser()  # обработчик столкновений - проверяет, сталкивается ли панда с чем-то
    #     self.queue = CollisionHandlerQueue()  # сюда записываются столкноения, которые будут обнаружены ударом
    #
    #     self.cTrav.addCollider(cnodepath,
    #                            self.queue)  # доавбляем нашу панду в обработчик, чтобы игра проверила стокновение
    #
    #     cnodepath.node().setIntoCollideMask(0)  # 0 - кто толкает, 1 - кто ждет толчка
    #
    #     cnodepath.node().setFromCollideMask(1)
    #
    #     levelCollider.node().setIntoCollideMask(1)  # коллизия уровня ждет столкновения, он терпила!
    #     self.IsGround = False
    #     self.taskMgr.add(self.checkCollision, "Col")
    #
    #     self.train = self.level.attachNewNode(CollisionNode("train"))
    #     self.train.node().addSolid(CollisionBox((-20, -20, 0), (50, 50, 200)))
    #     self.train.show()
    #     self.train.setPos(0, -1000, 0)
    #
    #     self.taskMgr.add(self.trainmove, "trainmove")
    # def trainmove(self,task):
    #     fps = task.time
    #     self.Train.setPos(self.Train.getPos() + Vec3(0, 0, -0.1 * fps))
    #     if self.Train.getPos().y > 50:
    #         self.train.setPos(0, -1000, 0)
    #     return task.cont
    #
    # def checkCollision(self, task):
    #     fps = task.time #кадрам
    #     if self.IsGround == True:
    #         print("on stoit")
    #     else:
    #         print("on w wozdyxe")
    #         self.PandaActor.setPos(self.PandaActor.getPos() + Vec3(0, 0, -0.1 * fps))
    #
    #     self.cTrav.traverse(self.render)  # запускаем проверку удар (т.е проверяем столкновения)
    #     if not self.queue.getNumEntries():  # если нет столкноений
    #         return Task.cont
    #
    #     print(self.queue)  # выводим информацию о столкновениях для корректной работы (для отладки)
    #     self.queue.sortEntries()  # сортировка по ближайшим столкновениям, чтобы все по порядку отработать
    #
    #     for entry in self.queue.getEntries():  # перебираем все столкновения
    #         name = entry.getIntoNodePath().getName()
    #         if name == "LevelCollider":
    #             self.IsGround = True
    #             print("isgrond +")
    #             #self.PandaActor.setPos(0, -30, 10)
    #             #self.IsGround = False
    #         print(f"Столкновение с {name}")  # выводим имя объекта, с которым столкнулись
    #
    #     return task.cont
    #
    # #########################################################################################################
    #
    # def updateKey(self, key, status):
    #     self.keyMap[key] = status
    #
    # def update(self, task):
    #     fps = task.time
    #     if self.keyMap["up"]:
    #         self.PandaActor.setPos(self.PandaActor.getPos() + Vec3(0, -0.1 * fps, 0))
    #     if self.keyMap["down"]:
    #         self.PandaActor.setPos(self.PandaActor.getPos() + Vec3(0, 0.1 * fps, 0))
    #     if self.keyMap["left"]:
    #         self.PandaActor.setPos(self.PandaActor.getPos() + Vec3(-0.1 * fps, 0, 0))
    #     if self.keyMap["right"]:
    #         self.PandaActor.setPos(self.PandaActor.getPos() + Vec3(0.1 * fps, 0, 0))
    #     return Task.cont
    #
    # # задача это написать функцию в которой мы будем "прикреплены" к панде
    # # self.camera.setPos(self.PandaActor.getX(), self.PandaActor.getY() - 15, self.PandaActor.getZ() + 10)
    # # self.camera.lookAt(self.PandaActor)
    # def lalala(self, task):
    #     self.camera.setPos(self.PandaActor.getX(), self.PandaActor.getY() - 15, self.PandaActor.getZ() + 10)
    #     self.camera.lookAt(self.PandaActor)
    #     return Task.cont
    #
    # # Дальше оформляйте на другие кнопки
    # def test(self):
    #     self.x = self.x + 0.1
    #     self.PandaActor.setPos(self.x, self.y, self.z)
    #     # SetPos
    #     # Сделать управление на все кнопки
    #     print("Cобытие клавиша нажата W")
    #
    #     # Сделать управление влево вправо
    #
    # def PandaMove(self, task):
    #     speed = task.time * 6.0
    #     self.PandaActor.setPos(0, -speed, 0)
    #     return Task.cont
    #
    # def spinCameraTask(self, task):
    #     angleDegrees = task.time * 6.0
    #     angleRadians = angleDegrees * (pi / 180.0)
    #     self.camera.setHpr(angleDegrees, 0, 0)
        # return Task.cont

app = MyApp()
app.run()