• Ce sujet contient 0 réponse, 1 participant et a été mis à jour pour la dernière fois par GrandJo, le il y a 2 années.
Vous lisez 0 fil de discussion
  • Auteur
    Messages
    • #65763
      GrandJo
      Participant

      Bonjour gamecodeurs(euses),

      je m’initie à la prog de jeu avec LUA. Voila je suis sur mon premier jeu (le casse brique) et je rencontre un bug que je ne comprend pas.

      Mon jeu se déroule dans un rectangle à l’intérieur de l’écran. jusque la tout va bien.
      je voudrais que si le joueur modifie la taille de l’écran, le rectangle ou surface de jeu s’adapte aussi donc j’ai créé une variable « border » qui peut varier.

      Si border = 0, en gros fullécran

      si border > 0 , dessine un rectangle fond noir de dimension ( largeur – 2 * border) et (hauteur – 2 * border)

      Ceci fonctionne bien

      Maintenant, lorsque je déplace la raquette je voudrais qu’elle reste dans ce rectangle délimité par la variable « border », rectangle qui s’adapte au mode de résolution de l’écran.

      Mon premier test avec Border = 10

      Si la position suivant x de la raquette est <ou> à la largeur du rectangle alors
      la raquette se repositionne respectivement dans le cadre.

      Les autres tests avec Border > 10
      J’ai un effet de bord qui apparait, la raquette ne se décalle plus correctement, la balle rebondit sur des murs invisibles…..

      Help me please.

      Je suis un peu perdu la.

      Merci bien

      
      
      -- ** Author : BINYOUM Joseph
      -- ** Date :24/07/2020
      -- ** Description: Jeu casse Brique
      
      --Objet qui contient les differents modes de résolution de l'écran
      -- ainsi le programmeur peut choisir celui qui l'interesse
      -- Confere sortie console pour faire un choix
      
      local screenMode = {}
      screenMode.All = {}
      screenMode.width = 0
      screenMode.height = 0
      
      -- Objet représentant une raquette
      local Pad = {}
      Pad.x = 0
      Pad.y = 0
      Pad.largeur = 80
      Pad.hauteur = 20
      
      --Objet représentant une balle
      local balle = {}
      balle.x = 0
      balle.y = 0
      balle.rayon = 10
      balle.Vx = 0
      balle.Vy = 0
      balle.colle = false
      
      --Fonction lance le jeu
      function Demarre()
        balle.colle = true
      end
      
      --Cette fonction charge les réglages du jeu
      function love.load()
        
        screenMode.All = love.window.getFullscreenModes()
      
        love.graphics.setBackgroundColor(1,1,1)    -- couleur fond d'ecran en blanc
        
        --Affiche tous les modes de résolution disponibles
        for m, p in pairs(screenMode.All) do
          print(("[%d] { width: %d , height: %d }"):format(m,p.width,p.height))
        end
        
        --choix d'un mode de resolution
        screenMode.width = screenMode.All[3].width
        screenMode.height = screenMode.All[3].height
        
        
        success = love.window.setMode(screenMode.width, screenMode.height)
        
        largeur = love.graphics.getWidth()
        hauteur = love.graphics.getHeight()
        border = 50
        
        print(largeur, hauteur)
        --Defini un titre pour le projet
        love.window.setTitle("CASSE BRIQUE")
        
        Demarre()
        
      end
      
      --Cette fonction animent les images
      function love.update(dt)
        
        --Le pad suit la position du curseur de la souris suivant X
        Pad.x = love.mouse.getX()
        Pad.y = hauteur - Pad.hauteur /2 - border
      
        --le pad est contraint sur le rectangle de largeur 1180
        if Pad.x >= (largeur - 2 * border) then
          Pad.x = largeur - (Pad.largeur/2 + border)
        end
        if Pad.x <= border then
          Pad.x = border + Pad.largeur / 2
        end
        
        --Si la balle est collée sur le pad alors synchronise les position
        if balle.colle then
          balle.x = Pad.x 
          balle.y = Pad.y - Pad.hauteur/2 - balle.rayon
        else
          balle.x = balle.x + balle.Vx * dt
          balle.y = balle.y + balle.Vy * dt
        end
        
        --si la balle rencontre un mur
         if balle.x >= (largeur - 2*border) then
          balle.Vx = 0 - balle.Vx
          balle.x =  largeur - 2*border
        end
        if balle.x <= (border + balle.rayon) then
          balle.Vx = 0 - balle.Vx
          balle.x =  border + balle.rayon
        end
        if balle.y <= (border + balle.rayon) then
          balle.Vy = 0 - balle.Vy
          balle.y = border + balle.rayon
        end
        if balle.y >= hauteur then
          balle.colle = true
        end
        
        --Test de la collision de la balle et la raquette
        local posiYCollision = Pad.y - Pad.hauteur/2 - balle.rayon
        
        if balle.y > posiYCollision then
          local dist = math.abs(Pad.x - balle.x)
          if dist < Pad.largeur then
            balle.Vy = 0 - balle.Vy
            balle.y = posiYCollision
          end
        end
        
      end
      
      --Cette fonction affiche les images
      function love.draw()
        --Dessine un rectangle
        love.graphics.setColor(0,0,0)
        love.graphics.rectangle("fill", border, border, largeur- (2*border), hauteur-(2*border))
        
        --Dessine un pad
        love.graphics.setColor(1,0,1)
        love.graphics.rectangle("fill", Pad.x - (Pad.largeur/2), Pad.y - (Pad.hauteur/2) , Pad.largeur, Pad.hauteur)
        
        --Dessine la balle
        love.graphics.circle("fill",balle.x, balle.y, balle.rayon)
      end
      
      function love.mousepressed(x,y,n)
        if balle.colle == true then
          balle.colle = false
          --la balle se lance
          balle.Vx = 200
          balle.Vy = -200
        end
        
      end
      
Vous lisez 0 fil de discussion
  • Vous devez être connecté pour répondre à ce sujet.