from direct.showbase.ShowBase import ShowBase
from panda3d.core import CollisionTraverser, CollisionHandlerQueue, CollisionNode, CollisionRay, BitMask32
from direct.interval.LerpInterval import LerpPosInterval

class Game(ShowBase):
    def __init__(self):
        ShowBase.__init__(self)

        base.disableMouse()
        camera.setPos(0, 0, 5)
        camera.setHpr(-90, -90, -90)

        self.replace = {}

        node = loader.loadModel("a")
        node.reparentTo(render)
        node.setPos(-0.6, 0.6, 0)
        node.setCollideMask(BitMask32.bit(1))

        node1 = loader.loadModel("b")
        node1.reparentTo(render)
        node1.setPos(-0.6, -0.6, 0)
        node1.setCollideMask(BitMask32.bit(1))
        
        base.accept('mouse1', self.pick)

        self.CurPicker = CollisionTraverser()
        #self.CurPicker.showCollisions(render)
        self.CurPickerOr = CollisionHandlerQueue()
        CurPickerNod = CollisionNode('mouseRay')
        CurPickerCam = camera.attachNewNode(CurPickerNod)
        CurPickerNod.setFromCollideMask(BitMask32.bit(1))
        self.CurPickerRay = CollisionRay()
        CurPickerNod.addSolid(self.CurPickerRay)
        self.CurPicker.addCollider(CurPickerCam, self.CurPickerOr)

    def pick(self):
       if base.mouseWatcherNode.hasMouse():
           mpos = base.mouseWatcherNode.getMouse()
           self.CurPickerRay.setFromLens(base.camNode, mpos.getX(), mpos.getY())
           self.CurPicker.traverse(render)
           self.CurPickerOr.sortEntries()
           
           if (self.CurPickerOr.getNumEntries() > 0):
            info = self.CurPickerOr.getEntry(0)

            self.replace[info.getIntoNodePath().getName()] = info.getIntoNodePath()

            if len(self.replace) >=2:
                replace = list(self.replace.values())
                LerpPosInterval(nodePath = replace[0], other = render, blendType = 'easeInOut', duration = 0.2, pos = replace[1].getPos(render)).start()
                LerpPosInterval(nodePath = replace[1], other = render, blendType = 'easeInOut', duration = 0.2, pos = replace[0].getPos(render)).start()
                self.replace = {}

game = Game()
game.run()

from direct.showbase.ShowBase import ShowBase
from panda3d.core import CollisionTraverser, CollisionNode, CollisionRay, CollisionHandlerQueue

class Game(ShowBase):
    def __init__(self):
        ShowBase.__init__(self)
        
        self.keyMap = {"forward": 0, "back": 0}

        self.accept("w", self.setKey, ["forward", True])
        self.accept("w-up", self.setKey, ["forward", False])
        
        self.accept("s", self.setKey, ["back", True])
        self.accept("s-up", self.setKey, ["back", False])

        terrain = loader.loadModel("colltest")
        terrain.reparentTo(render)
        terrain.setCollideMask(1)

        self.player = loader.loadModel("panda")
        self.player.reparentTo(render)

        fromObject = self.player.attachNewNode(CollisionNode('colNode'))
        fromObject.setZ(1)
        fromObject.node().addSolid(CollisionRay(0, 0, 0, 0, 0, -1))
        fromObject.node().setFromCollideMask(1)

        self.queue = CollisionHandlerQueue()

        self.collTrav = CollisionTraverser()
        self.collTrav.addCollider(fromObject, self.queue)

        taskMgr.add(self.update, 'update')

    def setKey(self, key, value):
        self.keyMap[key] = value

    def update(self, task):
        dt = globalClock.getDt()

        self.collTrav.traverse(render)
        self.queue.sortEntries()

        if (self.queue.getNumEntries() > 0):
            info = self.queue.getEntry(0)
            self.player.setPos(info.getSurfacePoint(render))
            
        if self.keyMap["forward"]:
            self.player.setY(self.player, -10 * dt)
            
        if self.keyMap["back"]:
            self.player.setY(self.player, 10 * dt)

        return task.cont

game = Game()
game.run()

from panda3d.core import loadPrcFileData

confVars = '''
window-title Моя деревня
'''

from direct.showbase.ShowBase import ShowBase
from panda3d.core import CollisionTraverser, CollisionHandlerPusher
from panda3d.core import CollisionNode, CollisionSphere, CollisionInvSphere

import panda3d.core as p3d
p3d.load_prc_file_data('', '''win-size 800 600
                            multisamples 1
                            show-frame-rate-meter 1
                            sync-video 0''')

import configparser

FT_MIPMAP = p3d.SamplerState.FT_linear_mipmap_linear
FT_LINEAR = p3d.SamplerState.FT_linear
TS_NORMAL = p3d.TextureStage.M_normal
TS_NORMAL_GLOSS = p3d.TextureStage.M_normal_gloss
TS_MODULATE = p3d.TextureStage.M_modulate
F_SRGB = p3d.Texture.F_srgb
F_SRGBA = p3d.Texture.F_srgb_alpha
F_RGB = p3d.Texture.F_rgb
F_RGBA = p3d.Texture.F_rgba
M_MSAA= p3d.AntialiasAttrib.M_multisample

"""direct - это часть Panda3D, написанная на Python core - это C++ с привязками Python)
ShowBase-это одноэлементный класс, который настраивает окно, диспетчер задач и все
другие общие вещи, которые вы можете (или не можете) использовать.
Вам не нужно его использовать, но вы, вероятно, захотите использовать или использовать его, даже если вы этого не хотите.
Он также устанавливает себя и кучу других вещей в здания, так что
ключевые объекты (например, узел рендерин доступны в любом месте вашего код"""

# Класс контроллера мыши и клавы
class Controller():
   # Конструктор
   def __init__(self):
      
      #self.cTrav = CollisionTraverser()
      #self.pusher = CollisionHandlerPusher()
      # Значение шага перемещения клавы
      self.key_step = 0.1
      # Значение шага поворота мыши
      self.mouse_step = 0.2
      # Координаты ценра экрана
      self.x_center = base.win.getXSize()//2
      self.y_center = base.win.getYSize()//2
      # Перемещаем указатель мыши в цетре экрана
      base.win.movePointer(0, self.x_center, self.y_center)
      # Отключаем стандарное управление мышкой
      base.disableMouse()
      # Устанавливает поле зрения обьекта
      base.camLens.setFov(30)
      
      
      # Устанавливает текущее значение ориентациии камеры
      self.heading = 0
      self.pitch = 0
      
      # Запускаем задачу контроля камеры
      taskMgr.doMethodLater(0.05, self.controlCamera, "camera-task")
      
      # Регистрируем на нажатие клавиши "Esc"
      # Событие закрытия приложения
      base.accept("escape", base.userExit)
      
      # Устанавливаем клавиши управления перемещения камеры
      # Словарь хранящий флаги нажатия клавиш
      self.keys = dict()
      
      # Заполняем словарь
      for key in ['a', 'd', 'w', 's', 'e', 'q']:
         # Создаем запись в словаре
         self.keys [key]= 0
         # Регестрируем событие на нажатие клавиш
         base.accept(key, self.setKey, [key, 1])
         # Регестрируем событие на отжатие клавиш
         base.accept(key+'-up', self.setKey, [key, 0])

   # Метод установки состояния клавиш
   def setKey(self, key, value):
      self.keys [key]= value
      
   # Метод управления положением и ориентации камеры
   def controlCamera(self, task):
      # Расчитывем управлением и ориентации камерры
      move_x = self.key_step * (self.keys['d'] - self.keys['a'])
      # Добавьте перемещение камеры вперед, назад, вверх, вниз
      move_y = self.key_step * (self.keys['w'] - self.keys['s'])
      move_z = self.key_step * (self.keys['e'] - self.keys['q'])
         
      # Смещаем позицию камеры относительно предыдущего положения камеры
      base.camera.setPos(base.camera, move_x, move_y, move_z)
      
      # Получаем новое положение курсора мыши
      new_mouse_pos = base.win.getPointer(0)
      new_x = new_mouse_pos.getX()
      new_y = new_mouse_pos.getY()
      # Пробуем установить курсор в цетре экрана
      if base.win.movePointer(0, self.x_center, self.y_center):
         # Расчитайте поворот камеры по горизонтали
         self.heading = self.heading - (new_x - self.x_center) * self.mouse_step
         # Расчитайте поворот камеры по диагонали
         self.pitch = self.pitch - (new_y - self.y_center) * self.mouse_step
         # Устанавливаем новую ориентацию камеры
         base.camera.setHpr(self.heading, self.pitch, 0)
            
      # Сообщаем о необходимости повторного запуска камеры
      return task.again

if __name__ == '__main__':

   
   class App(ShowBase):
      def __init__(self):
         
         super().__init__()
         
         
         self.cTrav = CollisionTraverser()
        
         pusher = CollisionHandlerPusher()
         pusher.setHorizontal(True)
         
         self.env = loader.loadModel("models/world")
         self.env.reparent_to(self.render)
         self.env.setScale(0.25, 0.25, 0.25)
         self.env.setPos(0, 0, -2)
         
         envBounds = self.env.getBounds()
         envCenter = envBounds.getCenter()
         envRad = envBounds.getRadius() * 0.8
         
         

         cNode = CollisionNode("models/world")
         cNode.addSolid(CollisionInvSphere(envCenter, envRad))
         envC = self.render.attachNewNode(cNode)
        
         camBounds = self.camera.getBounds()
         camCenter = camBounds.getCenter()
         camRad = 1
         
         cNode = CollisionNode("camera")
         cNode.addSolid(CollisionSphere(camCenter, camRad))
         camC = self.camera.attachNewNode(cNode)
         camC.show()
        
         self.cTrav.addCollider(camC, pusher)
         pusher.addCollider(camC, self.camera)

         

         self.controller = Controller()

   app=App()
   app.run()

  def mouse_left_click(self):
        if base.mouseWatcherNode.hasMouse():
            mpos = base.mouseWatcherNode.getMouse()
            self.mpos_x = mpos[0]
            self.mpos_y = mpos[1]        
            self.pickerRay.setFromLens(base.camNode,mpos.getX(),mpos.getY())
            self.picker.traverse(render)
            print("лево")
            if self.number_click == 1:
                 self.number_click += 1

            if self.pq.getNumEntries() > 0:
                print("1")
                self.pq.sortEntries()
                pickedObj = self.pq.getEntry(0).getIntoNodePath()
                t = pickedObj.getNetTag('slot')
                print(t)

  def collisionSlot(self, pos_x, pos_y, slot, number):
        sprite = self.loader.loadModel("assets/eggs/64_64")
        sprite.reparentTo(render)
        sprite.setScale(11.25, 15, 15)
        sprite.setPos(pos_x, 1, pos_y)
        sprite.setCollideMask(BitMask32.bit(1))
        sprite.setTag(str(slot), str(number))
        return sprite