Sorry your browser is not supported!

Function Bubble_GetNeighbors (Tile as Bubble_tile_type)
	
    /*
    
   //var neighborsoffsets = [[[1, 0], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1]], // Even row tiles PAIR < --------------------------- Original array declaration.
   //                     [[1, 0], [1, 1], [0, 1], [-1, 0], [0, -1], [1, -1]]];  // Odd row tiles IMPAIR
    
    function getNeighbors(tile) {
        var tilerow = (tile.y + rowoffset) % 2; // Even or odd row
        var neighbors = [];
        
        // Get the neighbor offsets for the specified tile
        var n = neighborsoffsets[tilerow];
        
        // Get the neighbors
        for (var i=0; i<n.length; i++) {
            // Neighbor coordinate
            var nx = tile.x + n[i][0]; <-------------------------------------------------------------
            var ny = tile.y + n[i][1]; < ------------------------------------------------------------
            
            // Make sure the tile is valid
            if (nx >= 0 && nx < level.columns && ny >= 0 && ny < level.rows) {
                neighbors.push(level.tiles[nx][ny]);
            }
        }
        
        return neighbors;
    }
    */	
	
    // Get the neighbors of the specified tile
    
   Local i as Integer
	
   Local TileRow as Integer
   
   Tilerow = Mod(Tile.y + Bubble_rowoffset,2)    
   
   Local Neighbors as Bubble_tile_type[]
   
   Local Neighborsoffsets_x as Integer [6] 
   Local Neighborsoffsets_y as Integer [6]
   
   Local n_x as Integer 
   Local n_y as Integer

// could you confirm this part is ok <------------------------------------- start
   

	Select TileRow
		
		Case 0
	
			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 0
			Neighborsoffsets_x [2] = -1
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = -1
			Neighborsoffsets_x [5] = 0
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
		
		EndCase
		
		Case 1

			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 1
			Neighborsoffsets_x [2] = 0
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = 0
			Neighborsoffsets_x [5] = 1
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
			
		EndCase
		
		Case Default
			
			Message ("Error TileRow should be 0 or 1")
			
		EndCase
	
	EndSelect

// could you confirm this part is ok <--------------------------------------------- end
				
   // Get the neighbor offsets for the specified tile
   
    // Get the neighbors
    For i=0 to 5
    	
	    	Local Nx as Integer
	   	Local Ny as Integer
	   	
		Nx = Tile.x + Neighborsoffsets_x [i]   <------------------------------------ could you confirm this ok
		Ny = Tile.y + Neighborsoffsets_y [i]  <------------------------------------ could you confirm this ok
		
	    // Make sure the tile is valid
	    If Nx > 0
	    		If Nx < Bubble_niveau.Colonnes
	    			If Ny > 0 
	    				If  Ny <= Bubble_niveau.Rangees
	    					Neighbors.Insert (Bubble_niveau.Tableau_tiles[nx,ny])
	    					
	    					local Pos as Bubble_coord_type
	    					Local Col1 as Integer
	    					Local Col2 as Integer
	    					
	    					Col1 = MakeColor (255,0,0)
	    					Col2 = MakeColor (255,255,255)
	    					
	    					Pos = Bubble_getTileCoordinate (Nx, Ny)
	    					
	    					DrawEllipse (Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y + Bubble_niveau.Hauteur_tile/2, 10,10,Col1,Col1,1)
						
						Pos = Bubble_getTileCoordinate (Tile.x, Tile.y)
						
	    					DrawEllipse (Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y + Bubble_niveau.Hauteur_tile/2, 15,15,Col2,Col2,1)
	    					
				    EndIf
				 EndIf
			Endif
		EndIf
	    	
	 Next
	 
EndFunction Neighbors

// Project: Jeu_bubble_tir
// Created: 19-07-08

 
// ------------------------------------------------------------------------
// Bubble Shooter Game Tutorial With HTML5 And JavaScript
// Copyright (c) 2015 Rembound.com
// 
// This program is free software: you can redistribute it and/or modify  
// it under the terms of the GNU General Public License as published by  
// the Free Software Foundation, either version 3 of the License, or  
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,  
// but WITHOUT ANY WARRANTY; without even the implied warranty of  
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
// GNU General Public License for more details.  
// 
// You should have received a copy of the GNU General Public License  
// along with this program.  If not, see http://www.gnu.org/licenses/.
//
// http://rembound.com/articles/bubble-shooter-game-tutorial-with-html5-and-javascript
// ------------------------------------------------------------------------


// ------------------------------------------------------------------------
//
// DECLARATIONS
//
// ------------------------------------------------------------------------


#Constant BUBBLE_VITESSE_DEPLACEMENT_BUBBLE 16.0
#Constant BUBBLE_MAX_COLOR 7
#Constant BUBBLE_NOMBRE_RANGEES_DEPART 4


#Constant JEU_INIT 0
#Constant JEU_READY 1
#Constant JEU_SHOOTBUBBLE 2
#Constant JEU_REMOVECLUSTER 3
#Constant JEU_GAMEOVER 4

#Constant TRUE 0
#Constant FALSE 1

// ------------------------------------------------------------------------


// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle("Jeu_bubble_tir")
SetWindowSize(1024, 768, 0)
SetWindowAllowResize(1) // allow the user to resize the window

// set display properties
SetVirtualResolution(1024, 768) // doesn't have to match the window
SetOrientationAllowed(1, 1, 1, 1) // allow both portrait and landscape on mobile devices
SetSyncRate(30, 0) // 30fps instead of 60 to save battery
SetScissor(0, 0, 0, 0) // use the maximum available screen space, no black borders
UseNewDefaultFonts(1)

// ------------------------------------------------------------------------

Type Bubble_tile_type
	
	x as Integer
	y as Integer
	Modele as Integer // type dans le code initial
	bRemoved as Integer // removed dans le code initial
	Velocite as Integer
	bProcessed as integer // processed dans code original
	
	Sprite as Integer
	
EndType


Type Bubble_coord_type
	
	x as Integer
	y as Integer
	
EndType


Type Bubble_niveau_type
	
        x as Integer           // X position
        y as Integer          // Y position
        Largeur as Integer     // Width, gets calculated
        Hauteur as Integer    // Height, gets calculated
        Colonnes as Integer   // Number of tile columns
        Rangees as Integer    // Number of tile rows
        Largeur_tile as Integer // Visual width of a tile
        Hauteur_tile as Integer // Visual height of a tile
        Hauteur_rangee as Integer // Height of a row
        Rayon as Integer  //Bubble collision radius
        Tableau_tiles as Bubble_tile_type[100,100] // The two-dimensional tile array	

EndType

Global Bubble_niveau as Bubble_niveau_type

Type Bubble_bubble_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Vitesse as Integer
	Vitesse_chute as Integer
	Modele as Integer
	bVisible as Integer
	
EndType

Type Bubble_bubble_prochaine_type
	
	x as Integer
	y as Integer
	Modele as Integer
	
EndType

Type Bubble_joueur_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Modele as Integer
	Bubble as Bubble_bubble_type
	Prochaine_bubble as Bubble_bubble_prochaine_type
	
	Sprite_bubble as Integer
	Sprite_prochaine_bubble as Integer
	
EndType

Global Bubble_joueur as Bubble_joueur_type

Global Bubble_etat_jeu as Integer // Game states
  
Global Bubble_score as Integer
  
Global Bubble_turncounter as Integer
Global Bubble_rowoffset as Integer
  
Global Bubble_bShowCluster as Integer
  
Global Bubble_tableau_clusters as Bubble_tile_type[] // Clusters
Global Bubble_tableau_floating_clusters as Bubble_tile_type[-1,-1]
  
Global Bubble_image as Integer
  
Global Bubble_cluster as Bubble_tile_type[]
  
Global Bubble_debug_message as Integer

// ------------------------------------------------------------------------
//
// FUNCTIONS
//
// ------------------------------------------------------------------------
 
  
Function Bubble_initialiser_jeu()
 	
 	
 	Bubble_debug_message = CreateText ("Debug")
 	SetTextPosition (Bubble_debug_message,10, 600)
 	SetTextSize (Bubble_debug_message, 30)
 	
 	
 	Bubble_etat_jeu = JEU_INIT
 	Bubble_score = 0
 	Bubble_turncounter = 0
 	Bubble_rowoffset = 0
 	
 	Bubble_animation_state = 0
 	Bubble_animation_time = 0
 	
 	Bubble_bShowCluster = FALSE
 	Bubble_tableau_clusters.Length = -1
 	//bubble_tableau_floating_cluster.Length = -1
 	
 	// Initialisation du niveau
 	
 	Bubble_niveau.x = 4
	Bubble_niveau.y = 83
	Bubble_niveau.Largeur = GetDeviceWidth()
	Bubble_niveau.Hauteur = GetDeviceHeight()
	Bubble_niveau.Colonnes = 15
	Bubble_niveau.Rangees = 16
	Bubble_niveau.Largeur_tile = 40
	Bubble_niveau.Hauteur_tile = 40
	Bubble_niveau.Hauteur_rangee = 34
	Bubble_niveau.Rayon = 20	
 	
 	// chargements image
    
    Bubble_image = LoadImage ("boules.png")
    
    // Initialisation du tableau de tiles.
    
    Local i as Integer
    Local j as Integer
    
    For i=0 to Bubble_niveau.Colonnes-1
    		For j=0 To Bubble_niveau.Rangees-1
    			
    			Local t as Bubble_tile_type
    			
    			t.x = i
    			t.y = j
    			t.Modele = 0
    			t.bRemoved = FALSE
    			t.Velocite = 0
    			t.bProcessed = FALSE
    			
    			Bubble_niveau.Tableau_tiles[i,j] = t
    			
    		Next
    	Next 
    	
    	// Initialisation tiles
    	
    	Bubble_niveau.Largeur = Bubble_niveau.Colonnes * Bubble_niveau.Largeur_tile + Bubble_niveau.Largeur_tile/2
    	bubble_niveau_hauteur = (Bubble_niveau.Rangees-1) * Bubble_niveau.Hauteur_rangee + Bubble_niveau.Hauteur_tile
    
     
   	// Initialisation du joueur
   	
   	Local Joueur_rangee as Integer
   	Local Joueur_colonne as Integer
   	
   	
	Joueur_colonne = Bubble_niveau.Colonnes / 2
	Joueur_rangee = Bubble_niveau.Rangees 
	
	Local Pos as Bubble_coord_type
	
	Pos = Bubble_GetTileCoordinate (Joueur_colonne, Joueur_rangee)
	   	
   	
   	Bubble_joueur.x = Pos.x
   	Bubble_joueur.y = Pos.y
   	Bubble_joueur.Angle = 90
   	Bubble_joueur.Modele = 0
   	Bubble_joueur.Prochaine_bubble.x = 800 
   	Bubble_joueur.Prochaine_bubble.y = 100 
   	
	Local b as Bubble_bubble_type
	Local pb as Bubble_bubble_prochaine_type
	
	Bubble_joueur.Angle = 0
	Bubble_joueur.Modele = 0
	
	Bubble_joueur.Sprite_bubble = CreateSprite (Bubble_image)
	Bubble_joueur.Sprite_prochaine_bubble = CreateSprite (Bubble_image)
	
	SetSpriteOffset (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	SetSpriteOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	
	SetSpriteDepth (Bubble_joueur.Sprite_bubble, 1)
	SetSpriteDepth (Bubble_joueur.Sprite_prochaine_bubble, 1)
	
	SetSpriteAnimation (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
	SetSpriteAnimation (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)		
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.x, Bubble_joueur.y)
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	
	
	b.x = 0
	b.y = 0
	b.Angle = 0
	b.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE
	b.Vitesse_chute = 900
	b.Modele = 0
	b.bVisible = FALSE
	
	Bubble_joueur.Bubble = b
	
	pb.x = 0
	pb.y = 0
	pb.Modele = 0

	Bubble_joueur.Prochaine_bubble = pb   	
   	
 EndFunction 

Function Bubble_jouer()
	
  		Select Bubble_etat_jeu
  			
  			Case JEU_INIT
  			EndCase
  			
  			Case JEU_READY
  				//Bubble_render()
  				Bubble_renderTiles()
  				Bubble_mouse()
  			EndCase
  			
  			Case JEU_SHOOTBUBBLE
  				Bubble_StateShootBubble()
  			EndCase
  			
  			Case JEU_REMOVECLUSTER
  				 Bubble_stateRemoveCluster()
  			EndCase
  			
  			Case JEU_GAMEOVER
  			EndCase
  			
  		EndSelect
  	
  EndFunction
   
   
Function Bubble_SetGameState (Etat_jeu as Integer)
	
	Bubble_etat_jeu = Etat_jeu
	
	Bubble_animation_state = 0
	Bubble_animationtime = 0
	
EndFunction

	
Function Bubble_StateShootBubble()
	
    // Bubble is moving
    
    // Move the bubble in the direction of the mouse
	
	Bubble_joueur.Bubble.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE

	Inc Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.Vitesse * Cos (Bubble_joueur.Bubble.Angle)
	Inc Bubble_joueur.Bubble.y, Bubble_joueur.Bubble.Vitesse * Sin (Bubble_joueur.Bubble.Angle)
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.y)
	
	If Bubble_joueur.bubble.x <= 0 //Bubble_niveau.x
		// Left edge
		Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
		Bubble_joueur.Bubble.x = 0 //Bubble_niveau.x
	Else
		If Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile >= (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile
			// Right edge
			Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
			Bubble_joueur.Bubble.x = (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile - Bubble_niveau.Largeur_tile
		Endif
	EndIf
		
	 // Collisions with the top of the level
	 If (Bubble_joueur.Bubble.y <= 0)
	 	// Top collision
	 	Bubble_joueur.Bubble.y = 0
	 	Bubble_SnapBubble()
	 	ExitFunction
	 EndIf
	 
      // Collisions with other tiles
      
      Local i as Integer
      Local j as Integer
      
      For i=0 to Bubble_niveau.Colonnes-1
      	
      	For j=0 To Bubble_niveau.Rangees-1
      		
      		Local tile as Bubble_tile_type
      		
      		tile = Bubble_niveau.Tableau_tiles[i,j]
      		
      		If tile.Modele < 0
      			Continue
      		EndIf
      		
      		Local Coord as Bubble_coord_type
      		
      		Coord = Bubble_GetTileCoordinate (i,j)
      		
      		If Bubble_determiner_intersection_cercle (Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile/2, Bubble_joueur.Bubble.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon, Coord.x + Bubble_niveau.Largeur_tile/2, Coord.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon) = TRUE
				// Intersection with a level bubble
				Bubble_SnapBubble()
				ExitFunction
			EndIf
			
		Next
		
	Next
	
EndFunction

Function Bubble_stateRemoveCluster()
	
	Local i as Integer
	Local j as Integer
	
 	Local Tile as Bubble_tile_type
	
	Bubble_resetRemoved()
	
	// Mark the tiles as removed
	For i=0 to Bubble_tableau_clusters.Length
		Bubble_tableau_clusters[i].bRemoved = TRUE
	Next
	
	// Find floating clusters
	Bubble_tableau_floating_clusters = Bubble_FindFloatingClusters()
	
	// Pop bubbles
		 
	Local bTilesLeft as Integer
	 
	bTilesleft = FALSE
	 
	For i=0 to Bubble_tableau_clusters.Length
	 	
	 	Tile = Bubble_tableau_clusters[i]
	 	
	 	If Tile.Modele >=0
	 		
	 		bTilesLeft = TRUE
			Tile.Modele = -1
	 		
	 	EndIf
	 		
	Next

	// Drop bubbles
		
	For i=0 to Bubble_tableau_floating_clusters.Length
		For j=0 to Bubble_tableau_floating_clusters[i].Length
					
			Tile = Bubble_tableau_floating_clusters[i,j]
			
			If Tile.Modele >= 0
					  	
				bTileLeft = TRUE
				Tile.Modele = -1
				
			EndIf
		Next
	Next
	
	//
	
	Bubble_RenderTilesAgain()	
	
	//
		
	If bTileLeft = FALSE
		
		// Next bubble
		Bubble_Nextbubble()
		
		Local bTileFound as Integer

		// Check for game over						
		bTileFound = FALSE
		For i=0 To Bubble_niveau.Colonnes-1
			For j=0 To Bubble_niveau.Rangees -1
				If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
					bTileFound = TRUE
					Exit
				Endif
			Next
		Next
		
		If bTileFound = TRUE
			Bubble_etat_jeu = JEU_READY
		Else
			// No tiles left, game over
			Bubble_etat_jeu = JEU_GAMEOVER
			ExitFunction
		Endif
		
	EndIf
		
EndFunction


Function Bubble_SnapBubble()
	
	// Snap bubble to the grid
	
	Local CenterX as Integer
	Local CenterY as Integer
	Local GridPos as Bubble_coord_type
	
	// Get the grid position
	
	CenterX = Bubble_joueur.bubble.x + Bubble_niveau.Largeur_tile/2
	centerY = Bubble_joueur.bubble.y + Bubble_niveau.Hauteur_tile/2
		
	GridPos = Bubble_GetGridPosition (CenterX, CenterY)
	
	// Make sure the grid position is valid
	
	If GridPos.x <0
		GridPos.x = 0
	Endif
	
	If GridPos.x >= Bubble_niveau.Colonnes
		GridPos.x = Bubble_niveau.Colonnes-1
	EndIf
	
	If GridPos.y < 0
		GridPos.y = 0
	EndIf
	
	If GridPos.y >= Bubble_niveau.Rangees
		GridPos.y = Bubble_niveau.Rangees-1
	EndIf
	
     // Check if the tile is empty

	Local bAjouterTile as Integer
	
	bAjouterTile = FALSE
	
	If Bubble_niveau.Tableau_tiles [Gridpos.x, Gridpos.y].Modele <> -1

		// Tile is not empty, shift the new tile downwards
		
		Local Nouvelle_rangee as Integer
		
		For 	Nouvelle_rangee = Gridpos.y+1 to Bubble_niveau.Rangees-1
			If Bubble_niveau.Tableau_tiles [GridPos.x, Nouvelle_rangee].Modele = -1
				Gridpos.y = Nouvelle_rangee
				bAjouterTile = TRUE
				Exit
			Endif
		Next
		
	Else
		
		bAjouterTile = TRUE
		
	EndIf
	
    // Add the tile to the grid
    
    If bAjouterTile = TRUE
    	
    		// Hide the player bubble
    		Bubble_joueur.bubble.bVisible = FALSE
    		
    		// Set the tile
    		Bubble_niveau.Tableau_tiles [GridPos.x,GridPos.y].Modele = Bubble_joueur.bubble.Modele
    		
	    	// Find clusters
	    	Bubble_tableau_clusters = Bubble_findCluster (GridPos.x, GridPos.y, TRUE, TRUE, FALSE)
	    	
	    SetTextString (Bubble_debug_message, (str(Bubble_tableau_clusters.Length)))
	    	
	    	If Bubble_tableau_clusters.Length >= 3 
	    		// Remove the cluster
	    		Bubble_etat_jeu = JEU_REMOVECLUSTER
	    		ExitFunction
	    	EndIf
	    	
	 EndIf
 
	// No clusters found
	
	Inc Bubble_turncounter,1
	
	If Bubble_turncounter >= 3
		// Add a row of bubbles
		Bubble_addBubbles()
		Bubble_turncounter = 0
		Bubble_rowoffset = Mod (Bubble_rowoffset+1, 2)
		
		If Bubble_checkGameOver()
			ExitFunction
		EndIf
		
	EndIf
		
	// re-render all the tiles
	
	Bubble_RenderTilesAgain()		
	
	// Next bubble
	
	Bubble_nextBubble()	
	Bubble_etat_jeu = JEU_READY
	
EndFunction

Function Bubble_RenderTilesAgain()
	
	Local i as Integer
	Local j as Integer
	
	Local Pos as Bubble_coord_type
	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_GetTileCoordinate (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1) 
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Pos.x,Pos.Y )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				SetSpriteFrame (Bubble_niveau.Tableau_tiles[i,j].Sprite,Bubble_niveau.Tableau_tiles[i,j].Modele+1)
			
			Else
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
			EndIf
				
		Next
		
	Next		
	
EndFunction

Function Bubble_CheckGameOver()
	
	Local i as Integer
	Local Resultat as Integer
	
	// Check for game over
	
	For i=0 To Bubble_niveau.Colonnes-1
		
		// Check if there are bubbles in the bottom row
		If Bubble_niveau.Tableau_tiles[i,Bubble_niveau.Rangees-1].Modele <> -1
			
			// Game over
			Bubble_NextBubble()
			Bubble_etat_jeu = JEU_GAMEOVER
			Resultat = TRUE
			SetTextString (Bubble_debug_message, "GAME OVER")
			ExitFunction Resultat
		EndIf
		
	Next
	
	Resultat = FALSE
	
EndFunction Resultat

Function Bubble_addBubbles()
	
	Local i as Integer
	Local j as Integer
	Local Modele as Integer
			
	
	Local Pos as Bubble_coord_type
	
	// Move the rows downwards

	For i=0 To Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-2
			
			Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
						
			Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j].Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
			
		Next
	Next
	
	
    // Add a new row of bubbles at the top of the rows
    
    For i=0 To Bubble_niveau.Colonnes-1
    	
    		Modele = Bubble_getExistingColor()
    		Bubble_niveau.Tableau_tiles[i,0].Modele = Modele
    		
    	Next
    	
    	// delete all the displayed tiles
    	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_GetTileCoordinate (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
			EndIf
				
		Next
		
	Next
    	
    	
 EndFunction

Function Bubble_findColors()
	
	// Find the remaining colors
	
	Local FoundColors as Integer[]
	Local ColorTable as Integer[]
	
	Local i as Integer
	Local j as Integer
	
	Local Tile as Bubble_tile_type
	
	For i=0 to BUBBLE_MAX_COLOR-1
		ColorTable.Insert (FALSE)
	Next
	
    // Check all tiles
	For i=0 to Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-1
			Tile = Bubble_niveau.Tableau_tiles[i,j]
			If Tile.Modele >=0
				If ColorTable[Tile.Modele] = FALSE
					ColorTable[Tile.Modele] = TRUE
					FoundColors.Insert (Tile.Modele)
				EndIf
			EndIf	
		Next
	Next
	 
EndFunction FoundColors        

Function Bubble_FindCluster (tx as Integer, ty as Integer, MatchType as Integer, Reset as Integer, SkipRemoved as Integer)
	// Find cluster at the specified tile location
	
	If Reset = TRUE
		// Reset the processed flags
		Bubble_resetProcessed()
	EndIf
	
	Local Target_tile as Bubble_tile_type
	
	 // Get the target tile. Tile coord must be valid.

	Target_tile = Bubble_niveau.Tableau_tiles [tx,ty]
	
	// Initialize the toprocess array with the specified tile
    
    Local ToProcess as Bubble_tile_type[]
   	Local Longueur_tableau_process as Integer
   	    
    ToProcess.Insert(Target_tile) // contient target_tile
    Longueur_tableau_process = 1
    
   	Target_tile.bProcessed = TRUE
   	
   	Local FoundCluster as Bubble_tile_type[]
   	
   	While (Longueur_tableau_process >= 0)
   		
         // Pop the last element from the array
   		Local CurrentTile as Bubble_tile_type
   		
   		CurrentTile = ToProcess[ToProcess.Length]
   		ToProcess.Remove (ToProcess.Length)
   		Dec Longueur_tableau_process, 1
   		
   		If CurrentTile.Modele = -1
   			Continue
   		EndIf   	
   		
   		// Skip tiles with the removed flag
   		If SkipRemoved = TRUE 
   			If 	CurrentTile.bRemoved = TRUE
   				Message ("Skipremoved et Enlevee = true")
   				Continue
   			EndIf
   		EndIf
   		
   		// Check if current tile has the right type, if matchtype is true
   		If ((MatchType=FALSE) or (CurrentTile.Modele = Target_tile.Modele))
   				
   			// Add current tile to the cluster
   			//Message ("Ajouter tile à cluster")
   			FoundCluster.Insert (CurrentTile)
   			
   			 // Get the neighbors of the current tile
   			Local Neighbors as Bubble_tile_type[]
   			Neighbors = Bubble_getNeighbors(CurrentTile) 
   			
   			// Check the type of each neighbor
   			For i=0 to Neighbors.Length
   				
   				If Neighbors[i].bProcessed = FALSE
   					
   					// Add the neighbor to the toprocess array
   					ToProcess.Insert (Neighbors[i])
   					Inc Longueur_tableau_process,1
   					Neighbors[i].bProcessed = TRUE
   					
   				EndIf
   				
   			Next
   			
   		EndIf
   		
   		//Message ("Longueur tableau = " + str(ToProcess.Length))
   		
   		If Longueur_tableau_process <= 0 Then Exit
   		
   		SetTextString (Bubble_debug_message, str(Longueur_tableau_process))
   		
   		If Longueur_tableau_process > 300 
   			SetTextString (Bubble_debug_message, "Depassement tableau process -> Exit function.")
   			Exit
   		EndIf
   		
   	EndWhile
  		
	// Return the found cluster
   		
  EndFunction FoundCluster

Function Bubble_FindFloatingClusters()
	
	Local i as Integer
	Local j as Integer
	Local k as Integer
	
	// Find floating clusters
	
	// Reset the processed flags
 	Bubble_resetProcessed()
	
	Local FoundClusters as Bubble_tile_type[-1,-1]
		
	For i=0 To Bubble_niveau.Colonnes-1
		For j=0 To Bubble_niveau.Rangees-1
			
			Local Tile as Bubble_tile_type
			
			Tile = Bubble_niveau.Tableau_tiles[i,j]
			
			If Tile.bProcessed = FALSE
				
				// Find all attached tiles
				
				Local FoundCluster as Bubble_tile_type[]
				
				FoundCluster = Bubble_findCluster (i,j,FALSE, FALSE, TRUE)
						
				// There must be a tile in the cluster
				If FoundCluster.Length <= 0
					continue
				EndIf
				
				// Check if the cluster is floating
				
				Local bFloating as Integer
				
				bFloating = TRUE
				
				For k=0 to FoundCluster.Length
					 // Tile is attached to the roof
					If FoundCluster[k].y = 0
						bFloating = FALSE
						Exit
					Endif
				Next
				
				If bFloating = TRUE
					FoundClusters.Insert (FoundCluster)
				EndIf
			EndIf
			
		Next
	
	Next
		
	
EndFunction FoundClusters     
    
Function Bubble_resetProcessed()
	
	// Reset the processed flags
	
	Local i as Integer
	Local j as Integer
	Local Index as Integer
	
	For i=0 to Bubble_niveau.Colonnes-1
		For j=0 To Bubble_niveau.Rangees-1
			Bubble_Niveau.Tableau_tiles[i,j].bProcessed = FALSE
		Next
	Next
	
EndFunction

Function Bubble_resetRemoved()
	
	// Reset the removed flags

	Local i as Integer
	Local j as Integer
	
	For i=0 to Bubble_niveau.Colonnes-1
		For j=0 To Bubble_niveau.Rangees-1
			Bubble_Niveau.Tableau_tiles[i,j].bRemoved = FALSE
		Next
	Next

EndFunction


Function Bubble_GetNeighbors (Tile as Bubble_tile_type)
	
    /*
    
	//var neighborsoffsets = [[[1, 0], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1]], // Even row tiles PAIR
   //                     [[1, 0], [1, 1], [0, 1], [-1, 0], [0, -1], [1, -1]]];  // Odd row tiles IMPAIR
    
    function getNeighbors(tile) {
        var tilerow = (tile.y + rowoffset) % 2; // Even or odd row
        var neighbors = [];
        
        // Get the neighbor offsets for the specified tile
        var n = neighborsoffsets[tilerow];
        
        // Get the neighbors
        for (var i=0; i<n.length; i++) {
            // Neighbor coordinate
            var nx = tile.x + n[i][0];
            var ny = tile.y + n[i][1];
            
            // Make sure the tile is valid
            if (nx >= 0 && nx < level.columns && ny >= 0 && ny < level.rows) {
                neighbors.push(level.tiles[nx][ny]);
            }
        }
        
        return neighbors;
    }
    */	
	
    // Get the neighbors of the specified tile
    
   Local i as Integer
	
   Local TileRow as Integer
   
   Tilerow = Mod(Tile.y + Bubble_rowoffset,2)    
   
   Local Neighbors as Bubble_tile_type[]
   
   Local Neighborsoffsets_x as Integer [6] 
   Local Neighborsoffsets_y as Integer [6]
   
   Local n_x as Integer 
   Local n_y as Integer

	Select TileRow
		
		Case 0
	
			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 0
			Neighborsoffsets_x [2] = -1
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = -1
			Neighborsoffsets_x [5] = 0
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
		
		EndCase
		
		Case 1

			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 1
			Neighborsoffsets_x [2] = 0
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = 0
			Neighborsoffsets_x [5] = 1
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
			
		EndCase
		
		Case Default
			
			Message ("Error TileRow should be 0 or 1")
			
		EndCase
	
	EndSelect
				
   // Get the neighbor offsets for the specified tile
   
    // Get the neighbors
    For i=0 to 5
    	
	    	Local Nx as Integer
	   	Local Ny as Integer
	   	
		Nx = Tile.x + Neighborsoffsets_x [i]   
		Ny = (Tile.y) + Neighborsoffsets_y [i]
		
	    // Make sure the tile is valid
	    If Nx > 0
	    		If Nx < Bubble_niveau.Colonnes
	    			If Ny > 0 
	    				If  Ny <= Bubble_niveau.Rangees
	    					
	    					Neighbors.Insert (Bubble_niveau.Tableau_tiles[nx,ny])
	    					
	    					local Pos as Bubble_coord_type
	    					Local Col1 as Integer
	    					Local Col2 as Integer
	    					
	    					Col1 = MakeColor (255,0,0)
	    					Col2 = MakeColor (255,255,255)
	    					
	    					Pos = Bubble_getTileCoordinate (Nx, Ny)
	    					
	    					DrawEllipse (Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y + Bubble_niveau.Hauteur_tile/2, 10,10,Col1,Col1,1)
						
						Pos = Bubble_getTileCoordinate (Tile.x, Tile.y)
						
	    					DrawEllipse (Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y + Bubble_niveau.Hauteur_tile/2, 15,15,Col2,Col2,1)
	    					
				    EndIf
				 EndIf
			Endif
		EndIf
	    	
	 Next
	 
EndFunction Neighbors

Function Bubble_renderTiles()
	
	// Render tiles
	
	Local i as Integer
	Local j as Integer
	
	// Top to bottom
	For j=0 to Bubble_niveau.Rangees-1
		For i=0 To Bubble_niveau.Colonnes-1
			
			Local Tile as Bubble_tile_type
			
             // Get the tile
			Tile = Bubble_niveau.Tableau_tiles[i,j]

             // Calculate the tile coordinates
			Local Coord as Bubble_coord_type
			Coord = Bubble_GetTileCoordinate (i,j)
			
			// Check if there is a tile present
			If Tile.Modele >= 0
				
                 // Draw the tile
				Bubble_drawBubble (Tile, Coord.x, Coord.y, Tile.Modele)
				
			EndIf
			
		Next
	
	Next
	
EndFunction

Function Bubble_renderPlayer()
	
	// Render the player bubble
	
	Local CenterX as Integer
	Local CenterY as Integer
	
	CenterX = Bubble_joueur.x + Bubble_niveau.Largeur_tile/2
	CenterY = Bubble_joueur.y + Bubble_niveau.Hauteur_tile/2
	
	// Draw the angle
	
	Local DestX as Integer
	Local DestY as Integer
	
	DestX = CenterX + 1.5 * Bubble_niveau.Largeur_tile * Cos (Bubble_joueur.Angle)
	DestY = CenterY + 1.5 * Bubble_niveau.Hauteur_tile * Sin (Bubble_joueur.Angle)
	
	DrawLine (CenterX, CenterY, DestX, DestY, 255,255,255)
	
	// Draw the next bubble
	
	Bubble_joueur.Prochaine_bubble.x = 800
	Bubble_joueur.Prochaine_bubble.y = 50
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.Modele+1)
	
	// Draw the bubble
	If Bubble_joueur.bubble.bVisible
			SetSpriteVisible (Bubble_joueur.Sprite_bubble, TRUE)
			SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
			SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	Else
		SetSpriteVisible (Bubble_joueur.Sprite_bubble, FALSE)
	EndIf
        
EndFunction 
    
Function Bubble_GetTileCoordinate (Colonne as Integer, Rangee as Integer)

	// Get the tile coordinate

	Local Tile as Bubble_coord_type
	
	Tile.x = Bubble_niveau.x + Colonne * Bubble_niveau.Largeur_tile
	
	// X offset for odd or even rows
	If Mod(Rangee + Bubble_rowoffset,2) = 0
		Inc Tile.x, Bubble_niveau.Largeur_tile/2
	EndIf
	
	Tile.y = Bubble_niveau.y + Rangee * Bubble_niveau.Hauteur_tile

EndFunction Tile

Function Bubble_GetGridPosition (x as Integer, y as Integer)
	
	Local Grille as Bubble_coord_type
	Local xOffset as Integer
	
	// Get the closest grid position
	
	// Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee ) Correction a Bubble_niveau.Hauteur_rangee-1
	Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee-1 )
	
	xOffset = 0
	
	// Check for offset
	If Mod (Grille.y + Bubble_rowoffset,2) = 0 
		xOffset = Bubble_niveau.Largeur_tile / 2
	EndIf
	
	Grille.x = Floor ( ((x - xOffset) - Bubble_niveau.x) / Bubble_niveau.Largeur_tile )
	
EndFunction Grille

Function Bubble_drawBubble (Tile as Bubble_tile_type, x as Integer, y as integer, Frame as Integer)
	 
    // Draw the bubble
    
    If Frame <0 or Frame >= BUBBLE_MAX_COLOR
    		ExitFunction
    	EndIf

    If GetSpriteExists (Tile.Sprite)
    		SetSpritePositionByOffset (Tile.Sprite, x, y)
    		SetSpriteFrame (Tile.Sprite, Frame+1)
    	Endif
        
EndFunction  
    	

Function Bubble_newGame()

    // Start a new game
			
	// Reset score
	Bubble_score = 0
	
	Bubble_turncounter = 0
	Bubble_rowoffset = 0
	
	// Set the gamestate to ready
	Bubble_etat_jeu = JEU_READY
	
    // Create the level
    Bubble_createLevel()
	
    // Init the next bubble and set the current bubble
    Bubble_nextBubble()
    Bubble_nextBubble()
    
EndFunction

Function Bubble_createLevel()

	// Create a random level

	Local i as Integer
	Local j as Integer
	
	Local Count as Integer
	
	Local RandomTile as Integer
	Local NewTile as Integer
	
	// Create a level with random tiles		
	
	For j=0 to Bubble_niveau.Rangees-1
		
		
		RandomTile = Random (0, BUBBLE_MAX_COLOR-1)
		
		Count = 0
		
		For i=0 To Bubble_niveau.Colonnes-1
			
			If Count > 2
				
				// Change the random tile
				
				NewTile = Random (0, BUBBLE_MAX_COLOR-1)
				
				// Make sure the new tile is different from the previous tile
				
				If NewTile = RandomTile
					NewTile = Mod (NewTile + 1, BUBBLE_MAX_COLOR)
				Endif
				
				RandomTile = NewTile
				
				Count = 0
				
			EndIf
			
			Inc Count, 1
			
			If j < BUBBLE_NOMBRE_RANGEES_DEPART //Bubble_niveau.Rangees /2
				
				Bubble_niveau.Tableau_tiles[i,j].Modele = RandomTile
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1)
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, i,j )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				
			Else
			
				Bubble_niveau.Tableau_tiles[i,j].Modele = -1
				
			Endif
			
		Next
		
	Next
		
EndFunction
			
Function Bubble_nextBubble()
	
	// Create a random bubble for the player
		
    // Set the current bubble
 	
	Bubble_joueur.Modele = Bubble_joueur.Prochaine_bubble.Modele
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Prochaine_bubble.Modele
	
	
	Bubble_joueur.bubble.x = Bubble_joueur.x
	Bubble_joueur.bubble.y = Bubble_joueur.y
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	
	Bubble_joueur.bubble.bVisible = TRUE
	
    // Get a random type from the existing colors

	Local NextColor as Integer
	
	Nextcolor = Bubble_getExistingColor()
	
	// Set the next bubble
	
	Bubble_joueur.Prochaine_bubble.Modele = NextColor		
	
EndFunction

Function Bubble_getExistingColor()
	
    // Get a random existing color
    
    Local ExistingColors as Integer[]
    
    Existingcolors = Bubble_FindColors()
    
    Local Bubble_Modele as Integer
    
    BubbleType = 0
    
    If (Existingcolors.Length > 0)
    		Bubble_Modele = ExistingColors[Random (0, ExistingColors.Length-1)]
    	EndIf
    	
 EndFunction Bubble_Modele
    
Function Bubble_Shoot_bubble()
	
	// Shoot the bubble
	
	// Shoot the bubble in the direction of the mouse
	
	Bubble_joueur.Bubble.x = Bubble_joueur.x
	Bubble_joueur.Bubble.y = Bubble_joueur.y
	Bubble_joueur.Bubble.Angle = Bubble_joueur.Angle
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Modele    		
	
	// Set the gamestate
	
	Bubble_etat_jeu = JEU_SHOOTBUBBLE
	
EndFunction
    
Function Bubble_determiner_intersection_cercle (x1 as Integer, y1 as Integer, r1 as Integer, x2 as Integer, y2 as Integer, r2 as Integer)
	
	// Check if two circles intersect
		
	Local Resultat as Integer
	
	Local dx as Integer
	Local dy as Integer
	Local Longueur as Integer
	
	// Calculate the distance between the centers
	
	dx = x1 - x2
	dy = y1 - y2
	Longueur = sqrt (dx * dx + dy * dy)
	
	If Longueur < r1 + r2
		// Circles intersect
		Resultat = TRUE
	Else
		Resultat = FALSE
	EndIf
	
EndFunction Resultat

Function Bubble_Mouse()
	
	Local Pos as Bubble_coord_type
	
	// Get the mouse position	
	Pos.x = GetRAWMouseX()
	Pos.y = GetRAWMouseY()
	
	Local MouseAngle as Integer
	
    // Get the mouse angle
	MouseAngle = atan2 ( (Pos.y - Bubble_joueur.y+Bubble_niveau.Hauteur_tile/2), Pos.x - (Bubble_joueur.x + Bubble_niveau.Largeur_tile/2))
	
    // Convert range to 0, 360 degrees
	If (MouseAngle < 0)
		MouseAngle = 180 + (180 + MouseAngle)
	EndIf
	
	SetTextString (Bubble_debug_message, str(MouseAngle))
	
    // Restrict angle 
    Local lbound as Integer
    Local ubound as Integer
     
    lbound = 200
    ubound = 340
     
     If MouseAngle < lbound
     	MouseAngle = lbound
 	Else
 		// Right
 		If MouseAngle > uBound
 			MouseAngle = uBound
 		Endif
 	Endif
 	
	// Set the player angle
	
	Bubble_joueur.Angle = MouseAngle
	
	// On mouse button click
	If GetRawMouseLeftPressed()
	
		If Bubble_etat_jeu = JEU_READY
			Bubble_shoot_bubble()
		EndIf
		
	EndIf
	
	
EndFunction

// -------
//
// PROGRAMME PRINCIPAL
//
// -------

Bubble_initialiser_jeu()
Bubble_newgame()

do
	
	Bubble_jouer()
	
	Print(ScreenFPS())
	Sync()
loop

// ------------------------------------------------------------------------
// Bubble Shooter Game Tutorial With HTML5 And JavaScript
// Copyright (c) 2015 Rembound.com
// 
// This program is free software: you can redistribute it and/or modify  
// it under the terms of the GNU General Public License as published by  
// the Free Software Foundation, either version 3 of the License, or  
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,  
// but WITHOUT ANY WARRANTY; without even the implied warranty of  
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
// GNU General Public License for more details.  
// 
// You should have received a copy of the GNU General Public License  
// along with this program.  If not, see http://www.gnu.org/licenses/.
//
// http://rembound.com/articles/bubble-shooter-game-tutorial-with-html5-and-javascript
// ------------------------------------------------------------------------

// The function gets called when the window is fully loaded
window.onload = function() {
    // Get the canvas and context
    var canvas = document.getElementById("viewport");
    var context = canvas.getContext("2d");
    
    // Timing and frames per second
    var lastframe = 0;
    var fpstime = 0;
    var framecount = 0;
    var fps = 0;
    
    var initialized = false;
    
    // Level
    var level = {
        x: 4,           // X position
        y: 83,          // Y position
        width: 0,       // Width, gets calculated
        height: 0,      // Height, gets calculated
        columns: 15,    // Number of tile columns
        rows: 14,       // Number of tile rows
        tilewidth: 40,  // Visual width of a tile
        tileheight: 40, // Visual height of a tile
        rowheight: 34,  // Height of a row
        radius: 20,     // Bubble collision radius
        tiles: []       // The two-dimensional tile array
    };

    // Define a tile class
    var Tile = function(x, y, type, shift) {
        this.x = x;
        this.y = y;
        this.type = type;
        this.removed = false;
        this.shift = shift;
        this.velocity = 0;
        this.alpha = 1;
        this.processed = false;
    };
    
    // Player
    var player = {
        x: 0,
        y: 0,
        angle: 0,
        tiletype: 0,
        bubble: {
                    x: 0,
                    y: 0,
                    angle: 0,
                    speed: 1000,
                    dropspeed: 900,
                    tiletype: 0,
                    visible: false
                },
        nextbubble: {
                        x: 0,
                        y: 0,
                        tiletype: 0
                    }
    };
    
    // Neighbor offset table
    var neighborsoffsets = [[[1, 0], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1]], // Even row tiles
                            [[1, 0], [1, 1], [0, 1], [-1, 0], [0, -1], [1, -1]]];  // Odd row tiles
    
    // Number of different colors
    var bubblecolors = 7;
    
    // Game states
    var gamestates = { init: 0, ready: 1, shootbubble: 2, removecluster: 3, gameover: 4 };
    var gamestate = gamestates.init;
    
    // Score
    var score = 0;
    
    var turncounter = 0;
    var rowoffset = 0;
    
    // Animation variables
    var animationstate = 0;
    var animationtime = 0;
    
    // Clusters
    var showcluster = false;
    var cluster = [];
    var floatingclusters = [];
    
    // Images
    var images = [];
    var bubbleimage;
    
    // Image loading global variables
    var loadcount = 0;
    var loadtotal = 0;
    var preloaded = false;
    
    // Load images
    function loadImages(imagefiles) {
        // Initialize variables
        loadcount = 0;
        loadtotal = imagefiles.length;
        preloaded = false;
        
        // Load the images
        var loadedimages = [];
        for (var i=0; i<imagefiles.length; i++) {
            // Create the image object
            var image = new Image();
            
            // Add onload event handler
            image.onload = function () {
                loadcount++;
                if (loadcount == loadtotal) {
                    // Done loading
                    preloaded = true;
                }
            };
            
            // Set the source url of the image
            image.src = imagefiles[i];
            
            // Save to the image array
            loadedimages[i] = image;
        }
        
        // Return an array of images
        return loadedimages;
    }
    
    // Initialize the game
    function init() {
        // Load images
        images = loadImages(["bubble-sprites.png"]);
        bubbleimage = images[0];
    
        // Add mouse events
        canvas.addEventListener("mousemove", onMouseMove);
        canvas.addEventListener("mousedown", onMouseDown);
        
        // Initialize the two-dimensional tile array
        for (var i=0; i<level.columns; i++) {
            level.tiles[i] = [];
            for (var j=0; j<level.rows; j++) {
                // Define a tile type and a shift parameter for animation
                level.tiles[i][j] = new Tile(i, j, 0, 0);
            }
        }
        
        level.width = level.columns * level.tilewidth + level.tilewidth/2;
        level.height = (level.rows-1) * level.rowheight + level.tileheight;
        
        // Init the player
        player.x = level.x + level.width/2 - level.tilewidth/2;
        player.y = level.y + level.height;
        player.angle = 90;
        player.tiletype = 0;
        
        player.nextbubble.x = player.x - 2 * level.tilewidth;
        player.nextbubble.y = player.y;
        
        // New game
        newGame();
        
        // Enter main loop
        main(0);
    }
    
    // Main loop
    function main(tframe) {
        // Request animation frames
        window.requestAnimationFrame(main);
    
        if (!initialized) {
            // Preloader
            
            // Clear the canvas
            context.clearRect(0, 0, canvas.width, canvas.height);
            
            // Draw the frame
            drawFrame();
            
            // Draw a progress bar
            var loadpercentage = loadcount/loadtotal;
            context.strokeStyle = "#ff8080";
            context.lineWidth=3;
            context.strokeRect(18.5, 0.5 + canvas.height - 51, canvas.width-37, 32);
            context.fillStyle = "#ff8080";
            context.fillRect(18.5, 0.5 + canvas.height - 51, loadpercentage*(canvas.width-37), 32);
            
            // Draw the progress text
            var loadtext = "Loaded " + loadcount + "/" + loadtotal + " images";
            context.fillStyle = "#000000";
            context.font = "16px Verdana";
            context.fillText(loadtext, 18, 0.5 + canvas.height - 63);
            
            if (preloaded) {
                // Add a delay for demonstration purposes
                setTimeout(function(){initialized = true;}, 1000);
            }
        } else {
            // Update and render the game
            update(tframe);
            render();
        }
    }
    
    // Update the game state
    function update(tframe) {
        var dt = (tframe - lastframe) / 1000;
        lastframe = tframe;
        
        // Update the fps counter
        updateFps(dt);
        
        if (gamestate == gamestates.ready) {
            // Game is ready for player input
        } else if (gamestate == gamestates.shootbubble) {
            // Bubble is moving
            stateShootBubble(dt);
        } else if (gamestate == gamestates.removecluster) {
            // Remove cluster and drop tiles
            stateRemoveCluster(dt);
        }
    }
    
    function setGameState(newgamestate) {
        gamestate = newgamestate;
        
        animationstate = 0;
        animationtime = 0;
    }
    
    function stateShootBubble(dt) {
        // Bubble is moving
        
        // Move the bubble in the direction of the mouse
        player.bubble.x += dt * player.bubble.speed * Math.cos(degToRad(player.bubble.angle));
        player.bubble.y += dt * player.bubble.speed * -1*Math.sin(degToRad(player.bubble.angle));
        
        // Handle left and right collisions with the level
        if (player.bubble.x <= level.x) {
            // Left edge
            player.bubble.angle = 180 - player.bubble.angle;
            player.bubble.x = level.x;
        } else if (player.bubble.x + level.tilewidth >= level.x + level.width) {
            // Right edge
            player.bubble.angle = 180 - player.bubble.angle;
            player.bubble.x = level.x + level.width - level.tilewidth;
        }
 
        // Collisions with the top of the level
        if (player.bubble.y <= level.y) {
            // Top collision
            player.bubble.y = level.y;
            snapBubble();
            return;
        }
        
        // Collisions with other tiles
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows; j++) {
                var tile = level.tiles[i][j];
                
                // Skip empty tiles
                if (tile.type < 0) {
                    continue;
                }
                
                // Check for intersections
                var coord = getTileCoordinate(i, j);
                if (circleIntersection(player.bubble.x + level.tilewidth/2,
                                       player.bubble.y + level.tileheight/2,
                                       level.radius,
                                       coord.tilex + level.tilewidth/2,
                                       coord.tiley + level.tileheight/2,
                                       level.radius)) {
                                        
                    // Intersection with a level bubble
                    snapBubble();
                    return;
                }
            }
        }
    }
    
    function stateRemoveCluster(dt) {
        if (animationstate == 0) {
            resetRemoved();
            
            // Mark the tiles as removed
            for (var i=0; i<cluster.length; i++) {
                // Set the removed flag
                cluster[i].removed = true;
            }
            
            // Add cluster score
            score += cluster.length * 100;
            
            // Find floating clusters
            floatingclusters = findFloatingClusters();
            
            if (floatingclusters.length > 0) {
                // Setup drop animation
                for (var i=0; i<floatingclusters.length; i++) {
                    for (var j=0; j<floatingclusters[i].length; j++) {
                        var tile = floatingclusters[i][j];
                        tile.shift = 0;
                        tile.shift = 1;
                        tile.velocity = player.bubble.dropspeed;
                        
                        score += 100;
                    }
                }
            }
            
            animationstate = 1;
        }
        
        if (animationstate == 1) {
            // Pop bubbles
            var tilesleft = false;
            for (var i=0; i<cluster.length; i++) {
                var tile = cluster[i];
                
                if (tile.type >= 0) {
                    tilesleft = true;
                    
                    // Alpha animation
                    tile.alpha -= dt * 15;
                    if (tile.alpha < 0) {
                        tile.alpha = 0;
                    }

                    if (tile.alpha == 0) {
                        tile.type = -1;
                        tile.alpha = 1;
                    }
                }                
            }
            
            // Drop bubbles
            for (var i=0; i<floatingclusters.length; i++) {
                for (var j=0; j<floatingclusters[i].length; j++) {
                    var tile = floatingclusters[i][j];
                    
                    if (tile.type >= 0) {
                        tilesleft = true;
                        
                        // Accelerate dropped tiles
                        tile.velocity += dt * 700;
                        tile.shift += dt * tile.velocity;
                            
                        // Alpha animation
                        tile.alpha -= dt * 8;
                        if (tile.alpha < 0) {
                            tile.alpha = 0;
                        }

                        // Check if the bubbles are past the bottom of the level
                        if (tile.alpha == 0 || (tile.y * level.rowheight + tile.shift > (level.rows - 1) * level.rowheight + level.tileheight)) {
                            tile.type = -1;
                            tile.shift = 0;
                            tile.alpha = 1;
                        }
                    }

                }
            }
            
            if (!tilesleft) {
                // Next bubble
                nextBubble();
                
                // Check for game over
                var tilefound = false
                for (var i=0; i<level.columns; i++) {
                    for (var j=0; j<level.rows; j++) {
                        if (level.tiles[i][j].type != -1) {
                            tilefound = true;
                            break;
                        }
                    }
                }
                
                if (tilefound) {
                    setGameState(gamestates.ready);
                } else {
                    // No tiles left, game over
                    setGameState(gamestates.gameover);
                }
            }
        }
    }
    
    // Snap bubble to the grid
    function snapBubble() {
        // Get the grid position
        var centerx = player.bubble.x + level.tilewidth/2;
        var centery = player.bubble.y + level.tileheight/2;
        var gridpos = getGridPosition(centerx, centery);

        // Make sure the grid position is valid
        if (gridpos.x < 0) {
            gridpos.x = 0;
        }
            
        if (gridpos.x >= level.columns) {
            gridpos.x = level.columns - 1;
        }

        if (gridpos.y < 0) {
            gridpos.y = 0;
        }
            
        if (gridpos.y >= level.rows) {
            gridpos.y = level.rows - 1;
        }

        // Check if the tile is empty
        var addtile = false;
        if (level.tiles[gridpos.x][gridpos.y].type != -1) {
            // Tile is not empty, shift the new tile downwards
            for (var newrow=gridpos.y+1; newrow<level.rows; newrow++) {
                if (level.tiles[gridpos.x][newrow].type == -1) {
                    gridpos.y = newrow;
                    addtile = true;
                    break;
                }
            }
        } else {
            addtile = true;
        }

        // Add the tile to the grid
        if (addtile) {
            // Hide the player bubble
            player.bubble.visible = false;
        
            // Set the tile
            level.tiles[gridpos.x][gridpos.y].type = player.bubble.tiletype;
            
            // Check for game over
            if (checkGameOver()) {
                return;
            }
            
            // Find clusters
            cluster = findCluster(gridpos.x, gridpos.y, true, true, false);
            
            if (cluster.length >= 3) {
                // Remove the cluster
                setGameState(gamestates.removecluster);
                return;
            }
        }
        
        // No clusters found
        turncounter++;
        if (turncounter >= 5) {
            // Add a row of bubbles
            addBubbles();
            turncounter = 0;
            rowoffset = (rowoffset + 1) % 2;
            
            if (checkGameOver()) {
                return;
            }
        }

        // Next bubble
        nextBubble();
        setGameState(gamestates.ready);
    }
    
    function checkGameOver() {
        // Check for game over
        for (var i=0; i<level.columns; i++) {
            // Check if there are bubbles in the bottom row
            if (level.tiles[i][level.rows-1].type != -1) {
                // Game over
                nextBubble();
                setGameState(gamestates.gameover);
                return true;
            }
        }
        
        return false;
    }
    
    function addBubbles() {
        // Move the rows downwards
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows-1; j++) {
                level.tiles[i][level.rows-1-j].type = level.tiles[i][level.rows-1-j-1].type;
            }
        }
        
        // Add a new row of bubbles at the top
        for (var i=0; i<level.columns; i++) {
            // Add random, existing, colors
            level.tiles[i][0].type = getExistingColor();
        }
    }
    
    // Find the remaining colors
    function findColors() {
        var foundcolors = [];
        var colortable = [];
        for (var i=0; i<bubblecolors; i++) {
            colortable.push(false);
        }
        
        // Check all tiles
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows; j++) {
                var tile = level.tiles[i][j];
                if (tile.type >= 0) {
                    if (!colortable[tile.type]) {
                        colortable[tile.type] = true;
                        foundcolors.push(tile.type);
                    }
                }
            }
        }
        
        return foundcolors;
    }
    
    // Find cluster at the specified tile location
    function findCluster(tx, ty, matchtype, reset, skipremoved) {
        // Reset the processed flags
        if (reset) {
            resetProcessed();
        }
        
        // Get the target tile. Tile coord must be valid.
        var targettile = level.tiles[tx][ty];
        
        // Initialize the toprocess array with the specified tile
        var toprocess = [targettile];
        targettile.processed = true;
        var foundcluster = [];

        while (toprocess.length > 0) {
            // Pop the last element from the array
            var currenttile = toprocess.pop();
            
            // Skip processed and empty tiles
            if (currenttile.type == -1) {
                continue;
            }
            
            // Skip tiles with the removed flag
            if (skipremoved && currenttile.removed) {
                continue;
            }
            
            // Check if current tile has the right type, if matchtype is true
            if (!matchtype || (currenttile.type == targettile.type)) {
                // Add current tile to the cluster
                foundcluster.push(currenttile);
                
                // Get the neighbors of the current tile
                var neighbors = getNeighbors(currenttile);
                
                // Check the type of each neighbor
                for (var i=0; i<neighbors.length; i++) {
                    if (!neighbors[i].processed) {
                        // Add the neighbor to the toprocess array
                        toprocess.push(neighbors[i]);
                        neighbors[i].processed = true;
                    }
                }
            }
        }
        
        // Return the found cluster
        return foundcluster;
    }
    
    // Find floating clusters
    function findFloatingClusters() {
        // Reset the processed flags
        resetProcessed();
        
        var foundclusters = [];
        
        // Check all tiles
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows; j++) {
                var tile = level.tiles[i][j];
                if (!tile.processed) {
                    // Find all attached tiles
                    var foundcluster = findCluster(i, j, false, false, true);
                    
                    // There must be a tile in the cluster
                    if (foundcluster.length <= 0) {
                        continue;
                    }
                    
                    // Check if the cluster is floating
                    var floating = true;
                    for (var k=0; k<foundcluster.length; k++) {
                        if (foundcluster[k].y == 0) {
                            // Tile is attached to the roof
                            floating = false;
                            break;
                        }
                    }
                    
                    if (floating) {
                        // Found a floating cluster
                        foundclusters.push(foundcluster);
                    }
                }
            }
        }
        
        return foundclusters;
    }
    
    // Reset the processed flags
    function resetProcessed() {
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows; j++) {
                level.tiles[i][j].processed = false;
            }
        }
    }
    
    // Reset the removed flags
    function resetRemoved() {
        for (var i=0; i<level.columns; i++) {
            for (var j=0; j<level.rows; j++) {
                level.tiles[i][j].removed = false;
            }
        }
    }
    
    // Get the neighbors of the specified tile
    function getNeighbors(tile) {
        var tilerow = (tile.y + rowoffset) % 2; // Even or odd row
        var neighbors = [];
        
        // Get the neighbor offsets for the specified tile
        var n = neighborsoffsets[tilerow];
        
        // Get the neighbors
        for (var i=0; i<n.length; i++) {
            // Neighbor coordinate
            var nx = tile.x + n[i][0];
            var ny = tile.y + n[i][1];
            
            // Make sure the tile is valid
            if (nx >= 0 && nx < level.columns && ny >= 0 && ny < level.rows) {
                neighbors.push(level.tiles[nx][ny]);
            }
        }
        
        return neighbors;
    }
    
    function updateFps(dt) {
        if (fpstime > 0.25) {
            // Calculate fps
            fps = Math.round(framecount / fpstime);
            
            // Reset time and framecount
            fpstime = 0;
            framecount = 0;
        }
        
        // Increase time and framecount
        fpstime += dt;
        framecount++;
    }
    
    // Draw text that is centered
    function drawCenterText(text, x, y, width) {
        var textdim = context.measureText(text);
        context.fillText(text, x + (width-textdim.width)/2, y);
    }
    
    // Render the game
    function render() {
        // Draw the frame around the game
        drawFrame();
        
        var yoffset =  level.tileheight/2;
        
        // Draw level background
        context.fillStyle = "#8c8c8c";
        context.fillRect(level.x - 4, level.y - 4, level.width + 8, level.height + 4 - yoffset);
        
        // Render tiles
        renderTiles();
        
        // Draw level bottom
        context.fillStyle = "#656565";
        context.fillRect(level.x - 4, level.y - 4 + level.height + 4 - yoffset, level.width + 8, 2*level.tileheight + 3);
        
        // Draw score
        context.fillStyle = "#ffffff";
        context.font = "18px Verdana";
        var scorex = level.x + level.width - 150;
        var scorey = level.y+level.height + level.tileheight - yoffset - 8;
        drawCenterText("Score:", scorex, scorey, 150);
        context.font = "24px Verdana";
        drawCenterText(score, scorex, scorey+30, 150);

        // Render cluster
        if (showcluster) {
            renderCluster(cluster, 255, 128, 128);
            
            for (var i=0; i<floatingclusters.length; i++) {
                var col = Math.floor(100 + 100 * i / floatingclusters.length);
                renderCluster(floatingclusters[i], col, col, col);
            }
        }
        
        
        // Render player bubble
        renderPlayer();
        
        // Game Over overlay
        if (gamestate == gamestates.gameover) {
            context.fillStyle = "rgba(0, 0, 0, 0.8)";
            context.fillRect(level.x - 4, level.y - 4, level.width + 8, level.height + 2 * level.tileheight + 8 - yoffset);
            
            context.fillStyle = "#ffffff";
            context.font = "24px Verdana";
            drawCenterText("Game Over!", level.x, level.y + level.height / 2 + 10, level.width);
            drawCenterText("Click to start", level.x, level.y + level.height / 2 + 40, level.width);
        }
    }
    
    // Draw a frame around the game
    function drawFrame() {
        // Draw background
        context.fillStyle = "#e8eaec";
        context.fillRect(0, 0, canvas.width, canvas.height);
        
        // Draw header
        context.fillStyle = "#303030";
        context.fillRect(0, 0, canvas.width, 79);
        
        // Draw title
        context.fillStyle = "#ffffff";
        context.font = "24px Verdana";
        context.fillText("Bubble Shooter Example - Rembound.com", 10, 37);
        
        // Display fps
        context.fillStyle = "#ffffff";
        context.font = "12px Verdana";
        context.fillText("Fps: " + fps, 13, 57);
    }
    
    // Render tiles
    function renderTiles() {
        // Top to bottom
        for (var j=0; j<level.rows; j++) {
            for (var i=0; i<level.columns; i++) {
                // Get the tile
                var tile = level.tiles[i][j];
            
                // Get the shift of the tile for animation
                var shift = tile.shift;
                
                // Calculate the tile coordinates
                var coord = getTileCoordinate(i, j);
                
                // Check if there is a tile present
                if (tile.type >= 0) {
                    // Support transparency
                    context.save();
                    context.globalAlpha = tile.alpha;
                    
                    // Draw the tile using the color
                    drawBubble(coord.tilex, coord.tiley + shift, tile.type);
                    
                    context.restore();
                }
            }
        }
    }
    
    // Render cluster
    function renderCluster(cluster, r, g, b) {
        for (var i=0; i<cluster.length; i++) {
            // Calculate the tile coordinates
            var coord = getTileCoordinate(cluster[i].x, cluster[i].y);
            
            // Draw the tile using the color
            context.fillStyle = "rgb(" + r + "," + g + "," + b + ")";
            context.fillRect(coord.tilex+level.tilewidth/4, coord.tiley+level.tileheight/4, level.tilewidth/2, level.tileheight/2);
        }
    }
    
    // Render the player bubble
    function renderPlayer() {
        var centerx = player.x + level.tilewidth/2;
        var centery = player.y + level.tileheight/2;
        
        // Draw player background circle
        context.fillStyle = "#7a7a7a";
        context.beginPath();
        context.arc(centerx, centery, level.radius+12, 0, 2*Math.PI, false);
        context.fill();
        context.lineWidth = 2;
        context.strokeStyle = "#8c8c8c";
        context.stroke();

        // Draw the angle
        context.lineWidth = 2;
        context.strokeStyle = "#0000ff";
        context.beginPath();
        context.moveTo(centerx, centery);
        context.lineTo(centerx + 1.5*level.tilewidth * Math.cos(degToRad(player.angle)), centery - 1.5*level.tileheight * Math.sin(degToRad(player.angle)));
        context.stroke();
        
        // Draw the next bubble
        drawBubble(player.nextbubble.x, player.nextbubble.y, player.nextbubble.tiletype);
        
        // Draw the bubble
        if (player.bubble.visible) {
            drawBubble(player.bubble.x, player.bubble.y, player.bubble.tiletype);
        }
        
    }
    
    // Get the tile coordinate
    function getTileCoordinate(column, row) {
        var tilex = level.x + column * level.tilewidth;
        
        // X offset for odd or even rows
        if ((row + rowoffset) % 2) {
            tilex += level.tilewidth/2;
        }
        
        var tiley = level.y + row * level.rowheight;
        return { tilex: tilex, tiley: tiley };
    }
    
    // Get the closest grid position
    function getGridPosition(x, y) {
        var gridy = Math.floor((y - level.y) / level.rowheight);
        
        // Check for offset
        var xoffset = 0;
        if ((gridy + rowoffset) % 2) {
            xoffset = level.tilewidth / 2;
        }
        var gridx = Math.floor(((x - xoffset) - level.x) / level.tilewidth);
        
        return { x: gridx, y: gridy };
    }

    
    // Draw the bubble
    function drawBubble(x, y, index) {
        if (index < 0 || index >= bubblecolors)
            return;
        
        // Draw the bubble sprite
        context.drawImage(bubbleimage, index * 40, 0, 40, 40, x, y, level.tilewidth, level.tileheight);
    }
    
    // Start a new game
    function newGame() {
        // Reset score
        score = 0;
        
        turncounter = 0;
        rowoffset = 0;
        
        // Set the gamestate to ready
        setGameState(gamestates.ready);
        
        // Create the level
        createLevel();

        // Init the next bubble and set the current bubble
        nextBubble();
        nextBubble();
    }
    
    // Create a random level
    function createLevel() {
        // Create a level with random tiles
        for (var j=0; j<level.rows; j++) {
            var randomtile = randRange(0, bubblecolors-1);
            var count = 0;
            for (var i=0; i<level.columns; i++) {
                if (count >= 2) {
                    // Change the random tile
                    var newtile = randRange(0, bubblecolors-1);
                    
                    // Make sure the new tile is different from the previous tile
                    if (newtile == randomtile) {
                        newtile = (newtile + 1) % bubblecolors;
                    }
                    randomtile = newtile;
                    count = 0;
                }
                count++;
                
                if (j < level.rows/2) {
                    level.tiles[i][j].type = randomtile;
                } else {
                    level.tiles[i][j].type = -1;
                }
            }
        }
    }
    
    // Create a random bubble for the player
    function nextBubble() {
        // Set the current bubble
        player.tiletype = player.nextbubble.tiletype;
        player.bubble.tiletype = player.nextbubble.tiletype;
        player.bubble.x = player.x;
        player.bubble.y = player.y;
        player.bubble.visible = true;
        
        // Get a random type from the existing colors
        var nextcolor = getExistingColor();
        
        // Set the next bubble
        player.nextbubble.tiletype = nextcolor;
    }
    
    // Get a random existing color
    function getExistingColor() {
        existingcolors = findColors();
        
        var bubbletype = 0;
        if (existingcolors.length > 0) {
            bubbletype = existingcolors[randRange(0, existingcolors.length-1)];
        }
        
        return bubbletype;
    }
    
    // Get a random int between low and high, inclusive
    function randRange(low, high) {
        return Math.floor(low + Math.random()*(high-low+1));
    }
    
    // Shoot the bubble
    function shootBubble() {
        // Shoot the bubble in the direction of the mouse
        player.bubble.x = player.x;
        player.bubble.y = player.y;
        player.bubble.angle = player.angle;
        player.bubble.tiletype = player.tiletype;

        // Set the gamestate
        setGameState(gamestates.shootbubble);
    }
    
    // Check if two circles intersect
    function circleIntersection(x1, y1, r1, x2, y2, r2) {
        // Calculate the distance between the centers
        var dx = x1 - x2;
        var dy = y1 - y2;
        var len = Math.sqrt(dx * dx + dy * dy);
        
        if (len < r1 + r2) {
            // Circles intersect
            return true;
        }
        
        return false;
    }
    
    // Convert radians to degrees
    function radToDeg(angle) {
        return angle * (180 / Math.PI);
    }
    
    // Convert degrees to radians
    function degToRad(angle) {
        return angle * (Math.PI / 180);
    }

    // On mouse movement
    function onMouseMove(e) {
        // Get the mouse position
        var pos = getMousePos(canvas, e);

        // Get the mouse angle
        var mouseangle = radToDeg(Math.atan2((player.y+level.tileheight/2) - pos.y, pos.x - (player.x+level.tilewidth/2)));

        // Convert range to 0, 360 degrees
        if (mouseangle < 0) {
            mouseangle = 180 + (180 + mouseangle);
        }

        // Restrict angle to 8, 172 degrees
        var lbound = 8;
        var ubound = 172;
        if (mouseangle > 90 && mouseangle < 270) {
            // Left
            if (mouseangle > ubound) {
                mouseangle = ubound;
            }
        } else {
            // Right
            if (mouseangle < lbound || mouseangle >= 270) {
                mouseangle = lbound;
            }
        }

        // Set the player angle
        player.angle = mouseangle;
    }
    
    // On mouse button click
    function onMouseDown(e) {
        // Get the mouse position
        var pos = getMousePos(canvas, e);
        
        if (gamestate == gamestates.ready) {
            shootBubble();
        } else if (gamestate == gamestates.gameover) {
            newGame();
        }
    }
    
    // Get the mouse position
    function getMousePos(canvas, e) {
        var rect = canvas.getBoundingClientRect();
        return {
            x: Math.round((e.clientX - rect.left)/(rect.right - rect.left)*canvas.width),
            y: Math.round((e.clientY - rect.top)/(rect.bottom - rect.top)*canvas.height)
        };
    }
    
    // Call init to start the game
    init();
};

// Project: Jeu_bubble_tir
// Created: 19-07-08

 
// ------------------------------------------------------------------------
// Bubble Shooter Game Tutorial With HTML5 And JavaScript
// Copyright (c) 2015 Rembound.com
// 
// This program is free software: you can redistribute it and/or modify  
// it under the terms of the GNU General Public License as published by  
// the Free Software Foundation, either version 3 of the License, or  
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,  
// but WITHOUT ANY WARRANTY; without even the implied warranty of  
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
// GNU General Public License for more details.  
// 
// You should have received a copy of the GNU General Public License  
// along with this program.  If not, see http://www.gnu.org/licenses/.
//
// http://rembound.com/articles/bubble-shooter-game-tutorial-with-html5-and-javascript
// ------------------------------------------------------------------------


// ------------------------------------------------------------------------
//
// DECLARATIONS
//
// ------------------------------------------------------------------------


#Constant BUBBLE_VITESSE_DEPLACEMENT_BUBBLE 16.0
#Constant BUBBLE_MAX_COLOR 7
#Constant BUBBLE_NOMBRE_RANGEES_DEPART 4


#Constant JEU_INIT 0
#Constant JEU_READY 1
#Constant JEU_SHOOTBUBBLE 2
#Constant JEU_REMOVECLUSTER 3
#Constant JEU_GAMEOVER 4

#Constant BUBBLE_ETAT_NORMAL 1
#Constant BUBBLE_ETAT_DEBUT 2
#Constant BUBBLE_ETAT_DETECTEE 3

#Constant TRUE 1
#Constant FALSE 0

// ------------------------------------------------------------------------


// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle("Jeu_bubble_tir")
SetWindowSize(1024, 768, 0)
SetWindowAllowResize(1) // allow the user to resize the window

// set display properties
SetVirtualResolution(1024, 768) // doesn't have to match the window
SetOrientationAllowed(1, 1, 1, 1) // allow both portrait and landscape on mobile devices
SetSyncRate(30, 0) // 30fps instead of 60 to save battery
SetScissor(0, 0, 0, 0) // use the maximum available screen space, no black borders
UseNewDefaultFonts(1)

// ------------------------------------------------------------------------

Type Bubble_tile_type
	
	x as Integer
	y as Integer
	Modele as Integer // type dans le code initial
	State as Integer // removed dans le code initial
	
	Sprite as Integer
	
	Sprite_marque as Integer
	
EndType


Type Bubble_coord_type
	
	x as Integer
	y as Integer
	
EndType


Type Bubble_niveau_type
	
        x as Integer           // X position
        y as Integer          // Y position
        Largeur as Integer     // Width, gets calculated
        Hauteur as Integer    // Height, gets calculated
        Colonnes as Integer   // Number of tile columns
        Rangees as Integer    // Number of tile rows
        Largeur_tile as Integer // Visual width of a tile
        Hauteur_tile as Integer // Visual height of a tile
        Hauteur_rangee as Integer // Height of a row
        Rayon as Integer  //Bubble collision radius
        Tableau_tiles as Bubble_tile_type[100,100] // The two-dimensional tile array	

EndType

Global Bubble_niveau as Bubble_niveau_type

Type Bubble_bubble_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Vitesse as Integer
	Vitesse_chute as Integer
	Modele as Integer
	bVisible as Integer
	
EndType

Type Bubble_bubble_prochaine_type
	
	x as Integer
	y as Integer
	Modele as Integer
	
EndType

Type Bubble_joueur_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Modele as Integer
	Bubble as Bubble_bubble_type
	Prochaine_bubble as Bubble_bubble_prochaine_type
	
	Sprite_bubble as Integer
	Sprite_prochaine_bubble as Integer
	
EndType

Type Bubble_marque_type 
	
	x as Integer
	y as Integer
	
	r as Integer
	g as Integer
	b as Integer
	
	Sprite as Integer
	
EndType

Function Bubble_marquer_tile (Colonne as Integer, Rangee as Integer, State as Integer)
	
	Local r as Integer
	Local g as Integer
	Local b as Integer
	
	Local Image as Integer
	
	If GetSpriteExists (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque) = TRUE
		DeleteSprite (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque)
	EndIf

	Image = Loadimage ("rond.png")
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque = CreateSprite (Image)
	SetSpriteOffset (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, GetImageWidth(Image)/2, GetImageHeight(Image)/2)
	SetSpriteDepth (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, 0)
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].State = State
	
    	Local Pos as Bubble_coord_type
    	
    	Pos = Bubble_GetTileCoordinate (Colonne, Rangee)
	SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y)
    	
	Select Bubble_niveau.Tableau_tiles [Colonne, Rangee].State
		
		Case BUBBLE_ETAT_NORMAL
			r = 255
			g = 255
			b = 255
		EndCase
		
		Case BUBBLE_ETAT_DEBUT
			r = 255
			g = 255
			b = 0
		EndCase
		
		Case BUBBLE_ETAT_DETECTEE
			r = 255
			g = 0
			b = 0
		EndCase
		
	EndSelect	
	
	SetSpriteColor (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, r, g, b, 255)
	
EndFunction

Global Bubble_joueur as Bubble_joueur_type

Global Bubble_etat_jeu as Integer // Game states
  
Global Bubble_score as Integer
  
Global Bubble_turncounter as Integer
Global Bubble_rowoffset as Integer
  
Global Bubble_image as Integer
  
//Global Bubble_cluster as Bubble_tile_type[]
  
Global Bubble_debug_message as Integer


Global Bubble_debug_mode as Integer

// ------------------------------------------------------------------------
//
// FUNCTIONS
//
// ------------------------------------------------------------------------
 
  
Function Bubble_initialiser_jeu()
 	
 	
 	Bubble_debug_message = CreateText ("Debug")
 	SetTextPosition (Bubble_debug_message,10, 600)
 	SetTextSize (Bubble_debug_message, 30)
 	
 	
 	Bubble_etat_jeu = JEU_INIT
 	Bubble_score = 0
 	Bubble_turncounter = 0
 	Bubble_rowoffset = 0
 	
 	//bubble_tableau_floating_cluster.Length = -1
 	
 	// Initialisation du niveau
 	
 	Bubble_niveau.x = 4
	Bubble_niveau.y = 83
	Bubble_niveau.Largeur = GetDeviceWidth()
	Bubble_niveau.Hauteur = GetDeviceHeight()
	Bubble_niveau.Colonnes = 15
	Bubble_niveau.Rangees = 16
	Bubble_niveau.Largeur_tile = 40
	Bubble_niveau.Hauteur_tile = 40
	Bubble_niveau.Hauteur_rangee = 34
	Bubble_niveau.Rayon = 20	
 	
 	// chargements image
    
    Bubble_image = LoadImage ("boules.png")
    
    // Initialisation du tableau de tiles.
    
    Local i as Integer
    Local j as Integer
    
    For i=0 to Bubble_niveau.Colonnes-1
    		For j=0 To Bubble_niveau.Rangees-1
    			
    			Local t as Bubble_tile_type
    			
    			t.x = i
    			t.y = j
    			t.Modele = 0
    			t.State = BUBBLE_ETAT_NORMAL
    			
    			Bubble_niveau.Tableau_tiles[i,j] = t
    			
    		Next
    	Next 
    	
    	// Initialisation tiles
    	
    	Bubble_niveau.Largeur = Bubble_niveau.Colonnes * Bubble_niveau.Largeur_tile + Bubble_niveau.Largeur_tile/2
    	bubble_niveau_hauteur = (Bubble_niveau.Rangees-1) * Bubble_niveau.Hauteur_rangee + Bubble_niveau.Hauteur_tile
    
     
   	// Initialisation du joueur
   	
   	Local Joueur_rangee as Integer
   	Local Joueur_colonne as Integer
   	
   	
	Joueur_colonne = Bubble_niveau.Colonnes / 2
	Joueur_rangee = Bubble_niveau.Rangees 
	
	Local Pos as Bubble_coord_type
	
	Pos = Bubble_GetTileCoordinate (Joueur_colonne, Joueur_rangee)
	   	
   	
   	Bubble_joueur.x = Pos.x
   	Bubble_joueur.y = Pos.y
   	Bubble_joueur.Angle = 90
   	Bubble_joueur.Modele = 0
   	Bubble_joueur.Prochaine_bubble.x = 800 
   	Bubble_joueur.Prochaine_bubble.y = 100 
   	
	Local b as Bubble_bubble_type
	Local pb as Bubble_bubble_prochaine_type
	
	Bubble_joueur.Angle = 0
	Bubble_joueur.Modele = 0
	
	Bubble_joueur.Sprite_bubble = CreateSprite (Bubble_image)
	Bubble_joueur.Sprite_prochaine_bubble = CreateSprite (Bubble_image)
	
	SetSpriteOffset (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	SetSpriteOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	
	SetSpriteDepth (Bubble_joueur.Sprite_bubble, 1)
	SetSpriteDepth (Bubble_joueur.Sprite_prochaine_bubble, 1)
	
	SetSpriteAnimation (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
	SetSpriteAnimation (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)		
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.x, Bubble_joueur.y)
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	
	
	b.x = 0
	b.y = 0
	b.Angle = 0
	b.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE
	b.Vitesse_chute = 900
	b.Modele = 0
	b.bVisible = FALSE
	
	Bubble_joueur.Bubble = b
	
	pb.x = 0
	pb.y = 0
	pb.Modele = 0

	Bubble_joueur.Prochaine_bubble = pb   	
   	
 EndFunction 

Function Bubble_jouer()
	
  		Select Bubble_etat_jeu
  			
  			Case JEU_INIT
  			EndCase
  			
  			Case JEU_READY
  				Bubble_renderTiles()
  				Bubble_mouse()
  				Bubble_renderPlayer()
  			EndCase
  			
  			Case JEU_SHOOTBUBBLE
  				Bubble_StateShootBubble()
  			EndCase
  			
  			Case JEU_REMOVECLUSTER
  				 //Bubble_stateRemoveCluster()
  			EndCase
  			
  			Case JEU_GAMEOVER
  			EndCase
  			
  		EndSelect
  	
  EndFunction
   
   
Function Bubble_SetGameState (Etat_jeu as Integer)
	
	Bubble_etat_jeu = Etat_jeu
	
	Bubble_animation_state = 0
	Bubble_animationtime = 0
	
EndFunction

	
Function Bubble_StateShootBubble()
	
    // Bubble is moving
    
    // Move the bubble in the direction of the mouse
	
	Bubble_joueur.Bubble.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE

	Inc Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.Vitesse * Cos (Bubble_joueur.Bubble.Angle)
	Inc Bubble_joueur.Bubble.y, Bubble_joueur.Bubble.Vitesse * Sin (Bubble_joueur.Bubble.Angle)
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.y)
	
	If Bubble_joueur.bubble.x <= 0 //Bubble_niveau.x
		// Left edge
		Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
		Bubble_joueur.Bubble.x = 0 //Bubble_niveau.x
	Else
		If Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile >= (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile
			// Right edge
			Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
			Bubble_joueur.Bubble.x = (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile - Bubble_niveau.Largeur_tile
		Endif
	EndIf
		
	 // Collisions with the top of the level
	 If (Bubble_joueur.Bubble.y <= 0)
	 	// Top collision
	 	Bubble_joueur.Bubble.y = 0
	 	Bubble_SnapBubble()
	 	ExitFunction
	 EndIf
	 
      // Collisions with other tiles
      
      Local i as Integer
      Local j as Integer
      
      For i=0 to Bubble_niveau.Colonnes-1
      	
      	For j=0 To Bubble_niveau.Rangees-1
      		
      		Local tile as Bubble_tile_type
      		
      		tile = Bubble_niveau.Tableau_tiles[i,j]
      		
      		If tile.Modele < 0
      			Continue
      		EndIf
      		
      		Local Coord as Bubble_coord_type
      		
      		Coord = Bubble_GetTileCoordinate (i,j)
      		
      		If Bubble_determiner_intersection_cercle (Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile/2, Bubble_joueur.Bubble.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon, Coord.x + Bubble_niveau.Largeur_tile/2, Coord.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon) = TRUE
				// Intersection with a level bubble
				Bubble_SnapBubble()
				ExitFunction
			EndIf
			
		Next
		
	Next
	
EndFunction


Function Bubble_SnapBubble()
	
	// Snap bubble to the grid
	
	Local CenterX as Integer
	Local CenterY as Integer
	Local GridPos as Bubble_coord_type
	
	// Get the grid position
	
	CenterX = Bubble_joueur.bubble.x + Bubble_niveau.Largeur_tile/2
	centerY = Bubble_joueur.bubble.y + Bubble_niveau.Hauteur_tile/2
		
	GridPos = Bubble_GetGridPosition (CenterX, CenterY)
	
	// Make sure the grid position is valid
	
	If GridPos.x <= 0
		GridPos.x = 0
	Endif
	
	If GridPos.x >= Bubble_niveau.Colonnes
		GridPos.x = Bubble_niveau.Colonnes-1
	EndIf
	
	If GridPos.y <=  0
		GridPos.y = 0
	EndIf
	
	If GridPos.y >= Bubble_niveau.Rangees
		GridPos.y = Bubble_niveau.Rangees-1
	EndIf
	
     // Check if the tile is empty

	Local bAjouterTile as Integer
	
	bAjouterTile = FALSE
	
	If Bubble_niveau.Tableau_tiles [Gridpos.x, Gridpos.y].Modele <> -1

		// Tile is not empty, shift the new tile downwards
		
		Local Nouvelle_rangee as Integer
		
		For 	Nouvelle_rangee = Gridpos.y+1 to Bubble_niveau.Rangees-1
			If Bubble_niveau.Tableau_tiles [GridPos.x, Nouvelle_rangee].Modele = -1
				Gridpos.y = Nouvelle_rangee
				bAjouterTile = TRUE
				Exit
			Endif
		Next
		
	Else
		
		bAjouterTile = TRUE
		
	EndIf
	
    // Add the tile to the grid
    
    If bAjouterTile = TRUE
    	
    		// Hide the player bubble
    		Bubble_joueur.bubble.bVisible = FALSE
    		
    		// Set the tile
    		Bubble_niveau.Tableau_tiles [GridPos.x,GridPos.y].Modele = Bubble_joueur.bubble.Modele
    		
	    	// Algorithme de marquage
	    	Bubble_findcluster (GridPos.x,GridPos.y)
	    	
	    	// Remove bubble marquees
	    	Bubble_remove_founded_cluster()
	    	
	    	// Remove floating clusters
	    //Bubble_remove_floating_clusters()
	    	
	EndIf
	    	
	    	
	// No clusters found
	
	Inc Bubble_turncounter,1
	
	If Bubble_turncounter >= 3
		// Add a row of bubbles
		Bubble_addBubbles()
		Bubble_turncounter = 0
		Bubble_rowoffset = Mod (Bubble_rowoffset+1, 2)
		
		If Bubble_checkGameOver()
			ExitFunction
		EndIf
		
	EndIf
		
	// re-render all the tiles
	
	Bubble_RenderTilesAgain()		
	
	// Next bubble
	
	Bubble_nextBubble()	
	Bubble_etat_jeu = JEU_READY
	
EndFunction

Function Bubble_changer_state (Colonne as Integer, Rangee as Integer, State as Integer)
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].State = State
	
EndFunction

Global Tableau_traitement_tiles as Bubble_tile_type[]

Function Bubble_remove_founded_cluster()
	
	Local i as Integer
	Local Colonne as Integer
	Local Rangee as Integer
	
	For i=0 To Tableau_traitement_tiles.length
		
		Colonne = Tableau_traitement_tiles[i].x
		Rangee = Tableau_traitement_tiles[i].y
		
		Bubble_niveau.Tableau_tiles[Colonne,Rangee].Modele = -1
		Bubble_niveau.Tableau_tiles[Colonne,Rangee].State = BUBBLE_ETAT_NORMAL
		
		If Bubble_debug_mode = TRUE
			If GetSpriteExists(Bubble_niveau.Tableau_tiles[Colonne,Rangee].Sprite_marque)
				DeleteSprite (Bubble_niveau.Tableau_tiles[Colonne,Rangee].Sprite_marque)
			EndIf
		EndIf
		
	Next
	
EndFunction

Function Bubble_marquer_voisins (Tableau_voisins_entree as Bubble_tile_type[], Modele_recherche as Integer)
	
	Local i as Integer
	Local Compteur as Integer
	
	Compteur = 0
	
	For i=0 To Tableau_voisins_entree.Length
			
		If Tableau_voisins_entree[i].Modele = Modele_recherche
			
			Tableau_traitement_tiles.Insert (Tableau_voisins_entree[i])
			
			Bubble_changer_state (Tableau_voisins_entree[i].x, Tableau_voisins_entree[i].y, BUBBLE_ETAT_DETECTEE)
			
			If Bubble_debug_mode = TRUE
				Bubble_marquer_tile (Tableau_voisins_entree[i].x, Tableau_voisins_entree[i].y, BUBBLE_ETAT_DETECTEE)
			EndIf
			
			Inc Compteur, 1
			
		EndIf
	Next	
	
EndFunction Compteur

Function Bubble_findcluster (Tile_colonne as Integer, Tile_rangee as Integer)
	
	Local Tile_depart as Bubble_tile_type
	local Tile_courante as Bubble_tile_type
	
	Local Tableau_voisins as Bubble_tile_type[]
	Local Copie_tableau_voisins as Bubble_tile_type[]

	Local Compteur_modele_trouve as Integer
	Local Modele_recherche as Integer
	Local bSortie as Integer

	Bubble_set_state (BUBBLE_ETAT_NORMAL)
	
	Tableau_traitement_tiles.Length=-1
	
	Tile_depart = Bubble_niveau.Tableau_tiles [Tile_colonne, Tile_rangee]
	
	If Bubble_debug_mode = TRUE
		Bubble_marquer_tile (Tile_colonne, Tile_rangee, BUBBLE_ETAT_DEBUT)
	EndIf

	Modele_recherche = Bubble_joueur.Modele
	
	Tile_courante = Tile_depart
	
	Tableau_voisins = Bubble_GetNeighbors (Tile_courante)	
	
	Compteur_modele_trouve = Bubble_marquer_voisins (Tableau_voisins, Modele_recherche)

	If Compteur_modele_trouve = 0
		ExitFunction
	Endif
	
	bSortie = FALSE
	
	While (bSortie = FALSE)
			
		If Tableau_voisins.Length > 0
			
			Copie_tableau_voisins = Tableau_voisins
			
			For i=0 To Copie_tableau_voisins.Length
				
				Tile_courante = Copie_Tableau_voisins[i]
				
				If Tile_courante.Modele = Modele_recherche
				
					Tableau_voisins = Bubble_GetNeighbors(Tile_courante)
					Compteur_modele_trouve = Bubble_marquer_voisins (Tableau_voisins, Modele_recherche)
					
				Else
					
					bSortie = TRUE
					
				EndIf
				
			Next
			
		EndIf
		
		IF Compteur_modele_trouve = 0
			
			bSortie = TRUE
			
		EndIf
		
	EndWhile
	
EndFunction

Function Bubble_remove_floating_clusters()
	
	Local Colonne as Integer
	Local Rangee as Integer
	
	Local Tile_courante as Bubble_tile_type
	
	For Colonne=0 To Bubble_niveau.Colonnes-1
		For Rangee=1 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[Rangee-1, Colonne].Modele = -1
				
				Bubble_niveau.Tableau_tiles[Rangee, Colonne].Modele = -1
				
			EndIf
			
		Next
	Next
	
EndFunction


Function Bubble_RenderTilesAgain()
	
	Local i as Integer
	Local j as Integer
	
	Local Pos as Bubble_coord_type
	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_GetTileCoordinate (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1) 
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Pos.x,Pos.Y )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				SetSpriteFrame (Bubble_niveau.Tableau_tiles[i,j].Sprite,Bubble_niveau.Tableau_tiles[i,j].Modele+1)
				
				If Bubble_debug_mode = TRUE
				
					If GetSpriteExists (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
					
					Bubble_marquer_tile (i, j,Bubble_niveau.Tableau_tiles[i,j].State)
					
				EndIf
			
			Else
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				If Bubble_debug_mode = TRUE
					If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
				EndIf
			EndIf
			
		Next
		
	Next		
	
EndFunction

Function Bubble_CheckGameOver()
	
	Local i as Integer
	Local Resultat as Integer
	
	// Check for game over
	
	For i=0 To Bubble_niveau.Colonnes-1
		
		// Check if there are bubbles in the bottom row
		If Bubble_niveau.Tableau_tiles[i,Bubble_niveau.Rangees-1].Modele <> -1
			
			// Game over
			Bubble_NextBubble()
			Bubble_etat_jeu = JEU_GAMEOVER
			Resultat = TRUE
			SetTextString (Bubble_debug_message, "GAME OVER")
			ExitFunction Resultat
		EndIf
		
	Next
	
	Resultat = FALSE
	
EndFunction Resultat

Function Bubble_addBubbles()
	
	Local i as Integer
	Local j as Integer
	Local Modele as Integer
			
	
	Local Pos as Bubble_coord_type
	
	// Move the rows downwards

	For i=0 To Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-2
			
			Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
						
			Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j].Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
			
		Next
	Next
	
	
    // Add a new row of bubbles at the top of the rows
    
    For i=0 To Bubble_niveau.Colonnes-1
    	
    		Modele = Bubble_getExistingColor()
    		Bubble_niveau.Tableau_tiles[i,0].Modele = Modele
    		
    	Next
    	
    	// delete all the displayed tiles
    	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_GetTileCoordinate (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				If Bubble_debug_mode = TRUE
					If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
				EndIf
				
			EndIf
				
		Next
		
	Next
    	
    	
 EndFunction

Function Bubble_findColors()
	
	// Find the remaining colors
	
	Local FoundColors as Integer[]
	Local ColorTable as Integer[]
	
	Local i as Integer
	Local j as Integer
	
	Local Tile as Bubble_tile_type
	
	For i=0 to BUBBLE_MAX_COLOR-1
		ColorTable.Insert (FALSE)
	Next
	
    // Check all tiles
	For i=0 to Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-1
			Tile = Bubble_niveau.Tableau_tiles[i,j]
			If Tile.Modele >=0
				If ColorTable[Tile.Modele] = FALSE
					ColorTable[Tile.Modele] = TRUE
					FoundColors.Insert (Tile.Modele)
				EndIf
			EndIf	
		Next
	Next
	 
EndFunction FoundColors        


Function Bubble_set_state(State as Integer)
	
	// Reset the processed flags
	
	Local i as Integer
	Local j as Integer
	Local Index as Integer
	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			Bubble_Niveau.Tableau_tiles[i,j].State = State
			
			If Bubble_debug_mode = TRUE
				If Bubble_Niveau.Tableau_tiles[i,j].Modele <> -1
					Bubble_marquer_tile (i,j, State)
				Endif
			Endif
		Next
		
	Next
	
EndFunction

Function Bubble_GetNeighbors (Tile as Bubble_tile_type)
	
    // Get the neighbors of the specified tile
    
   Local i as Integer
	
   Local TileRow as Integer
   
   Tilerow = Mod(Tile.y + Bubble_rowoffset,2)    
   
   Local Neighbors as Bubble_tile_type[]
   
   Local Neighborsoffsets_x as Integer [6] 
   Local Neighborsoffsets_y as Integer [6]
   
   Local n_x as Integer 
   Local n_y as Integer
   
	Select TileRow
		
		Case 0

			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 1
			Neighborsoffsets_x [2] = 0
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = 0
			Neighborsoffsets_x [5] = 1
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
			
		EndCase		
		
		Case 1
	
			Neighborsoffsets_x [0] = 1
			Neighborsoffsets_x [1] = 0
			Neighborsoffsets_x [2] = -1
			Neighborsoffsets_x [3] = -1
			Neighborsoffsets_x [4] = -1
			Neighborsoffsets_x [5] = 0
		
			Neighborsoffsets_y [0] = 0
			Neighborsoffsets_y [1] = 1
			Neighborsoffsets_y [2] = 1
			Neighborsoffsets_y [3] = 0
			Neighborsoffsets_y [4] = -1
			Neighborsoffsets_y [5] = -1
		
		EndCase
		
		Case Default
			
			Message ("Error TileRow should be 0 or 1")
			
		EndCase
	
	EndSelect
	
				
   // Get the neighbor offsets for the specified tile
   
    // Get the neighbors
    For i=0 to 5
    	
	    	Local Nx as Integer
	   	Local Ny as Integer
	   	
		Nx = Tile.x + Neighborsoffsets_x [i]   
		Ny = (Tile.y) + Neighborsoffsets_y [i]
		
	    // Make sure the tile is valid
	    If Nx >= 0
	    		If Nx <= Bubble_niveau.Colonnes
	    			If Ny >= 0 
	    				If  Ny <= Bubble_niveau.Rangees
	    					
	    					Neighbors.Insert (Bubble_niveau.Tableau_tiles[nx,ny])
	    					
				    EndIf
				 EndIf
			Endif
		EndIf
	    	
	 Next
	 
EndFunction Neighbors

Function Bubble_renderTiles()
	
	// Render tiles
	
	Local i as Integer
	Local j as Integer
	
	// Top to bottom
	For j=0 to Bubble_niveau.Rangees-1
		For i=0 To Bubble_niveau.Colonnes-1
			
			Local Tile as Bubble_tile_type
			
             // Get the tile
			Tile = Bubble_niveau.Tableau_tiles[i,j]

             // Calculate the tile coordinates
			Local Coord as Bubble_coord_type
			Coord = Bubble_GetTileCoordinate (i,j)
			
			// Check if there is a tile present
			If Tile.Modele >= 0
				
                 // Draw the tile
				Bubble_drawBubble (Tile, Coord.x, Coord.y, Tile.Modele)
				
			EndIf
			
		Next
	
	Next
	
EndFunction

Function Bubble_renderPlayer()
	
	// Render the player bubble
	
	Local CenterX as Integer
	Local CenterY as Integer
	
	CenterX = Bubble_joueur.x + Bubble_niveau.Largeur_tile/2
	CenterY = Bubble_joueur.y + Bubble_niveau.Hauteur_tile/2
	
	// Draw the angle
	
	Local DestX as Integer
	Local DestY as Integer
	
	DestX = CenterX + 1.5 * Bubble_niveau.Largeur_tile * Cos (Bubble_joueur.Angle)
	DestY = CenterY + 1.5 * Bubble_niveau.Hauteur_tile * Sin (Bubble_joueur.Angle)
	
	DrawLine (CenterX, CenterY, DestX, DestY, 255,255,255)
	
	// Draw the next bubble
	
	Bubble_joueur.Prochaine_bubble.x = 800
	Bubble_joueur.Prochaine_bubble.y = 50
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.Modele+1)
	
	// Draw the bubble
	If Bubble_joueur.bubble.bVisible
			SetSpriteVisible (Bubble_joueur.Sprite_bubble, TRUE)
			SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
			SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	Else
		SetSpriteVisible (Bubble_joueur.Sprite_bubble, FALSE)
	EndIf
        
EndFunction 
    
Function Bubble_GetTileCoordinate (Colonne as Integer, Rangee as Integer)

	// Get the tile coordinate

	Local Tile as Bubble_coord_type
	
	Tile.x = Bubble_niveau.x + Colonne * Bubble_niveau.Largeur_tile
	
	// X offset for odd or even rows
	If Mod(Rangee + Bubble_rowoffset,2) = 0
		Inc Tile.x, Bubble_niveau.Largeur_tile/2
	EndIf
	
	Tile.y = Bubble_niveau.y + Rangee * Bubble_niveau.Hauteur_tile

EndFunction Tile

Function Bubble_GetGridPosition (x as Integer, y as Integer)
	
	Local Grille as Bubble_coord_type
	Local xOffset as Integer
	
	// Get the closest grid position
	
	// Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee ) Correction a Bubble_niveau.Hauteur_rangee-1
	Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee-1 )
	
	xOffset = 0
	
	// Check for offset
	If Mod (Grille.y + Bubble_rowoffset,2) = 0 
		xOffset = Bubble_niveau.Largeur_tile / 2
	EndIf
	
	Grille.x = Floor ( ((x - xOffset) - Bubble_niveau.x) / Bubble_niveau.Largeur_tile )
	
EndFunction Grille

Function Bubble_drawBubble (Tile as Bubble_tile_type, x as Integer, y as integer, Frame as Integer)
	 
    // Draw the bubble
    
    If Frame <0 or Frame >= BUBBLE_MAX_COLOR
    		ExitFunction
    	EndIf

    If GetSpriteExists (Tile.Sprite)
    		SetSpritePositionByOffset (Tile.Sprite, x, y)
    		SetSpriteFrame (Tile.Sprite, Frame+1)
    	Endif
    	
	If Bubble_debug_mode = TRUE
		If GetSpriteExists (Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].Sprite_marque)
			DeleteSprite (Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].Sprite_marque)
		EndIf
	
		Bubble_marquer_tile (Tile.x, Tile.y,Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].State)
		
	Endif
	
EndFunction  
    	

Function Bubble_newGame()

    // Start a new game
			
	// Reset score
	Bubble_score = 0
	
	Bubble_turncounter = 0
	Bubble_rowoffset = 0
	
	// Set the gamestate to ready
	Bubble_etat_jeu = JEU_READY
	
    // Create the level
    Bubble_createLevel()
	
    // Init the next bubble and set the current bubble
    Bubble_nextBubble()
    Bubble_nextBubble()
    
EndFunction

Function Bubble_createLevel()

	// Create a random level

	Local i as Integer
	Local j as Integer
	
	Local Count as Integer
	
	Local RandomTile as Integer
	Local NewTile as Integer
	
	// Create a level with random tiles		
	
	For j=0 to Bubble_niveau.Rangees-1
		
		
		RandomTile = Random (0, BUBBLE_MAX_COLOR-1)
		
		Count = 0
		
		For i=0 To Bubble_niveau.Colonnes-1
			
			If Count > 2
				
				// Change the random tile
				
				NewTile = Random (0, BUBBLE_MAX_COLOR-1)
				
				// Make sure the new tile is different from the previous tile
				
				If NewTile = RandomTile
					NewTile = Mod (NewTile + 1, BUBBLE_MAX_COLOR)
				Endif
				
				RandomTile = NewTile
				
				Count = 0
				
			EndIf
			
			Inc Count, 1
			
			If j < BUBBLE_NOMBRE_RANGEES_DEPART //Bubble_niveau.Rangees /2
				
				Bubble_niveau.Tableau_tiles[i,j].Modele = RandomTile
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1)
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, i,j )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				
				If Bubble_debug_mode = TRUE
					Bubble_marquer_tile (i,j, BUBBLE_ETAT_NORMAL)				
				EndIf
				
			Else
			
				Bubble_niveau.Tableau_tiles[i,j].Modele = -1
				
			Endif
			
		Next
		
	Next
		
EndFunction
			
Function Bubble_nextBubble()
	
	// Create a random bubble for the player
		
    // Set the current bubble
 	
	Bubble_joueur.Modele = Bubble_joueur.Prochaine_bubble.Modele
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Prochaine_bubble.Modele
	
	
	Bubble_joueur.bubble.x = Bubble_joueur.x
	Bubble_joueur.bubble.y = Bubble_joueur.y
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	
	Bubble_joueur.bubble.bVisible = TRUE
	
    // Get a random type from the existing colors

	Local NextColor as Integer
	
	Nextcolor = Bubble_getExistingColor()
	
	// Set the next bubble
	
	Bubble_joueur.Prochaine_bubble.Modele = NextColor		
	
EndFunction

Function Bubble_getExistingColor()
	
    // Get a random existing color
    
    Local ExistingColors as Integer[]
    
    Existingcolors = Bubble_FindColors()
    
    Local Bubble_Modele as Integer
    
    BubbleType = 0
    
    If (Existingcolors.Length > 0)
    		Bubble_Modele = ExistingColors[Random (0, ExistingColors.Length-1)]
    	EndIf
    	
 EndFunction Bubble_Modele
    
Function Bubble_Shoot_bubble()
	
	// Shoot the bubble
	
	// Shoot the bubble in the direction of the mouse
	
	Bubble_joueur.Bubble.x = Bubble_joueur.x
	Bubble_joueur.Bubble.y = Bubble_joueur.y
	Bubble_joueur.Bubble.Angle = Bubble_joueur.Angle
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Modele 
	
	// Set the gamestate
	// Set the gamestate
	
	Bubble_etat_jeu = JEU_SHOOTBUBBLE
	
EndFunction
    
Function Bubble_determiner_intersection_cercle (x1 as Integer, y1 as Integer, r1 as Integer, x2 as Integer, y2 as Integer, r2 as Integer)
	
	// Check if two circles intersect
		
	Local Resultat as Integer
	
	Local dx as Integer
	Local dy as Integer
	Local Longueur as Integer
	
	// Calculate the distance between the centers
	
	dx = x1 - x2
	dy = y1 - y2
	Longueur = sqrt (dx * dx + dy * dy)
	
	If Longueur < r1 + r2
		// Circles intersect
		Resultat = TRUE
	Else
		Resultat = FALSE
	EndIf
	
EndFunction Resultat

Function Bubble_Mouse()
	
	Local Pos as Bubble_coord_type
	
	// Get the mouse position	
	Pos.x = GetRAWMouseX()
	Pos.y = GetRAWMouseY()
	
	Local MouseAngle as Integer
	
    // Get the mouse angle
	MouseAngle = atan2 ( (Pos.y - Bubble_joueur.y+Bubble_niveau.Hauteur_tile/2), Pos.x - (Bubble_joueur.x + Bubble_niveau.Largeur_tile/2))
	
    // Convert range to 0, 360 degrees
	If (MouseAngle < 0)
		MouseAngle = 180 + (180 + MouseAngle)
	EndIf
	
	SetTextString (Bubble_debug_message, str(MouseAngle))
	
    // Restrict angle 
    Local lbound as Integer
    Local ubound as Integer
     
    lbound = 200
    ubound = 340
     
     If MouseAngle < lbound
     	MouseAngle = lbound
 	Else
 		// Right
 		If MouseAngle > uBound
 			MouseAngle = uBound
 		Endif
 	Endif
 	
	// Set the player angle
	
	Bubble_joueur.Angle = MouseAngle
	
	// On mouse button click
	If GetRawMouseLeftPressed()
	
		If Bubble_etat_jeu = JEU_READY
			Bubble_shoot_bubble()
		EndIf
		
	EndIf
	
	
EndFunction

// -------
//
// PROGRAMME PRINCIPAL
//
// -------

Bubble_debug_mode = FALSE

Bubble_initialiser_jeu()
Bubble_newgame()

do
	
	Bubble_jouer()
	
	Print(ScreenFPS())
	Sync()
loop

// Project: Jeu_bubble_tir
// Created: 19-07-08

 
// ------------------------------------------------------------------------
// Bubble Shooter Game Tutorial With HTML5 And JavaScript
// Copyright (c) 2015 Rembound.com
// http://rembound.com/articles/bubble-shooter-game-tutorial-with-html5-and-javascript
// ------------------------------------------------------------------------


// ------------------------------------------------------------------------
//
// DECLARATIONS
//
// ------------------------------------------------------------------------


#Constant BUBBLE_VITESSE_DEPLACEMENT_BUBBLE 16.0
#Constant BUBBLE_MAX_COLOR 7
#Constant BUBBLE_NOMBRE_RANGEES_DEPART 4
#Constant BUBBLE_MAX_COMPTEUR_AJOUT_NOUVELLE_RANGEE 5

#Constant JEU_INIT 0
#Constant JEU_PRET 1
#Constant JEU_TIRER_BUBBLE 2
#Constant JEU_GAMEOVER 3

#Constant BUBBLE_ETAT_NORMAL 1
#Constant BUBBLE_ETAT_DEBUT 2
#Constant BUBBLE_ETAT_DETECTEE 3

#Constant TRUE 1
#Constant FALSE 0

Type Bubble_tile_type
	
	x as Integer
	y as Integer
	Modele as Integer 
	Etat as Integer 
	
	Sprite as Integer
	Sprite_marque as Integer
	
EndType


Type Bubble_coord_type
	
	x as Integer
	y as Integer
	
EndType


Type Bubble_niveau_type
	
        x as Integer           		// Position X
        y as Integer          		// Position Y
        Largeur as Integer     		// Largeur, sera calculée
        Hauteur as Integer    		// Hauteur, sera calculée
        Colonnes as Integer   		// Nombre de colonnes de tiles
        Rangees as Integer    		// Nombre de rangées de tiles
        Largeur_tile as Integer 		// Largeur réelle d'une tile en pixels
        Hauteur_tile as Integer 		// Hauteur réelle d'une tile en pixels
        Hauteur_rangee as Integer		// Hauteur d'une rangée en pixels.
        Rayon as Integer  			// Rayon de collision d'une bubble
        Tableau_tiles as Bubble_tile_type[100,100] // Tableau à deux dimensions des tiles.

EndType

Global Bubble_niveau as Bubble_niveau_type

Type Bubble_bubble_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Vitesse as Integer
	Vitesse_chute as Integer
	Modele as Integer
	bVisible as Integer
	
EndType

Type Bubble_bubble_prochaine_type
	
	x as Integer
	y as Integer
	Modele as Integer
	
EndType

Type Bubble_joueur_type
	
	x as Integer
	y as Integer
	Angle as Integer
	Modele as Integer
	Bubble as Bubble_bubble_type
	Prochaine_bubble as Bubble_bubble_prochaine_type
	
	Sprite_bubble as Integer
	Sprite_prochaine_bubble as Integer
	
EndType

Type Bubble_marque_type 
	
	x as Integer
	y as Integer
	
	r as Integer
	g as Integer
	b as Integer
	
	Sprite as Integer
	
EndType

Global Bubble_joueur as Bubble_joueur_type

Global Bubble_etat_jeu as Integer 
  
Global Bubble_score as Integer
  
Global Bubble_compteur_tour as Integer
Global Bubble_offset_rangee as Integer
  
Global Bubble_image as Integer
  
Global Bubble_debug_message as Integer

Global Bubble_debug_mode as Integer

// ------------------------------------------------------------------------
//
// FUNCTIONS
//
// ------------------------------------------------------------------------
 
  
Function Bubble_initialiser_jeu()
 	
 	Bubble_debug_message = CreateText ("Debug")
 	SetTextPosition (Bubble_debug_message,10, 600)
 	SetTextSize (Bubble_debug_message, 30)
 	
 	
 	Bubble_etat_jeu = JEU_INIT
 	Bubble_score = 0
 	Bubble_compteur_tour = 0
 	Bubble_offset_rangee= 0
 	
 	// Initialisation du niveau
 	
 	Bubble_niveau.x = 4
	Bubble_niveau.y = 83
	Bubble_niveau.Largeur = GetDeviceWidth()
	Bubble_niveau.Hauteur = GetDeviceHeight()
	Bubble_niveau.Colonnes = 15
	Bubble_niveau.Rangees = 16
	Bubble_niveau.Largeur_tile = 40
	Bubble_niveau.Hauteur_tile = 40
	Bubble_niveau.Hauteur_rangee = 34
	Bubble_niveau.Rayon = 20	
 	
 	// chargements image
    
    Bubble_image = LoadImage ("boules.png")
    
    // Initialisation du tableau de tiles.
    
    Local i as Integer
    Local j as Integer
    
    For i=0 to Bubble_niveau.Colonnes-1
    		For j=0 To Bubble_niveau.Rangees-1
    			
    			Local t as Bubble_tile_type
    			
    			t.x = i
    			t.y = j
    			t.Modele = 0
    			t.Etat = BUBBLE_ETAT_NORMAL
    			
    			Bubble_niveau.Tableau_tiles[i,j] = t
    			
    		Next
    	Next 
    	
    	// Initialisation tiles
    	
    	Bubble_niveau.Largeur = Bubble_niveau.Colonnes * Bubble_niveau.Largeur_tile + Bubble_niveau.Largeur_tile/2
    	bubble_niveau_hauteur = (Bubble_niveau.Rangees-1) * Bubble_niveau.Hauteur_rangee + Bubble_niveau.Hauteur_tile
    
     
   	// Initialisation du joueur
   	
   	Local Joueur_rangee as Integer
   	Local Joueur_colonne as Integer
   	
   	
	Joueur_colonne = Bubble_niveau.Colonnes / 2
	Joueur_rangee = Bubble_niveau.Rangees 
	
	Local Pos as Bubble_coord_type
	
	Pos = Bubble_donner_coordonnees_tile (Joueur_colonne, Joueur_rangee)
	   	
   	
   	Bubble_joueur.x = Pos.x
   	Bubble_joueur.y = Pos.y
   	Bubble_joueur.Angle = 90
   	Bubble_joueur.Modele = 0
   	Bubble_joueur.Prochaine_bubble.x = 800 
   	Bubble_joueur.Prochaine_bubble.y = 100 
   	
	Local b as Bubble_bubble_type
	Local pb as Bubble_bubble_prochaine_type
	
	Bubble_joueur.Angle = 0
	Bubble_joueur.Modele = 0
	
	Bubble_joueur.Sprite_bubble = CreateSprite (Bubble_image)
	Bubble_joueur.Sprite_prochaine_bubble = CreateSprite (Bubble_image)
	
	SetSpriteOffset (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	SetSpriteOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile /2)
	
	SetSpriteDepth (Bubble_joueur.Sprite_bubble, 1)
	SetSpriteDepth (Bubble_joueur.Sprite_prochaine_bubble, 1)
	
	SetSpriteAnimation (Bubble_joueur.Sprite_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
	SetSpriteAnimation (Bubble_joueur.Sprite_prochaine_bubble, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)		
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.x, Bubble_joueur.y)
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	
	
	b.x = 0
	b.y = 0
	b.Angle = 0
	b.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE
	b.Vitesse_chute = 900
	b.Modele = 0
	b.bVisible = FALSE
	
	Bubble_joueur.Bubble = b
	
	pb.x = 0
	pb.y = 0
	pb.Modele = 0

	Bubble_joueur.Prochaine_bubble = pb   	
   	
 EndFunction 

Function Bubble_jouer()
	
	Select Bubble_etat_jeu

		Case JEU_INIT
		EndCase
		
		Case JEU_PRET
			Bubble_afficher_tiles()
			Bubble_gerer_souris()
			Bubble_afficher_joueur()
		EndCase
		
		Case JEU_TIRER_BUBBLE
			Bubble_gerer_tir_bubble()
		EndCase
		
		Case JEU_GAMEOVER
		EndCase
  			
	EndSelect
  	
EndFunction
  
Function Bubble_marquer_tile (Colonne as Integer, Rangee as Integer, Etat as Integer)
	
	Local r as Integer
	Local g as Integer
	Local b as Integer
	
	Local Image as Integer
	
	If GetSpriteExists (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque) = TRUE
		DeleteSprite (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque)
	EndIf

	Image = Loadimage ("rond.png")
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque = CreateSprite (Image)
	SetSpriteOffset (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, GetImageWidth(Image)/2, GetImageHeight(Image)/2)
	SetSpriteDepth (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, 0)
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].Etat = Etat
	
    	Local Pos as Bubble_coord_type
    	
    	Pos = Bubble_donner_coordonnees_tile (Colonne, Rangee)
	SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, Pos.x + Bubble_niveau.Largeur_tile/2, Pos.y)
    	
	Select Bubble_niveau.Tableau_tiles [Colonne, Rangee].Etat
		
		Case BUBBLE_ETAT_NORMAL
			r = 255
			g = 255
			b = 255
		EndCase
		
		Case BUBBLE_ETAT_DEBUT
			r = 255
			g = 255
			b = 0
		EndCase
		
		Case BUBBLE_ETAT_DETECTEE
			r = 255
			g = 0
			b = 0
		EndCase
		
	EndSelect	
	
	SetSpriteColor (Bubble_niveau.Tableau_tiles [Colonne, Rangee].Sprite_marque, r, g, b, 255)
	
EndFunction
	
Function Bubble_gerer_tir_bubble()
	
    // Bubble se déplace
    
    // Deplace la bubble selon la direction de la souris.
	
	Bubble_joueur.Bubble.Vitesse = BUBBLE_VITESSE_DEPLACEMENT_BUBBLE

	Inc Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.Vitesse * Cos (Bubble_joueur.Bubble.Angle)
	Inc Bubble_joueur.Bubble.y, Bubble_joueur.Bubble.Vitesse * Sin (Bubble_joueur.Bubble.Angle)
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.Bubble.x, Bubble_joueur.Bubble.y)
	
	If Bubble_joueur.bubble.x <= 0 //Bubble_niveau.x
		// Left edge
		Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
		Bubble_joueur.Bubble.x = 0 //Bubble_niveau.x
	Else
		If Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile >= (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile
			// Right edge
			Bubble_joueur.Bubble.Angle = 180 - Bubble_joueur.Bubble.Angle
			Bubble_joueur.Bubble.x = (Bubble_niveau.Colonnes+1) * Bubble_niveau.Largeur_tile - Bubble_niveau.Largeur_tile
		Endif
	EndIf
		
	 // Collision avec le haut de niveau
	 
	 If (Bubble_joueur.Bubble.y <= 0)
	 	Bubble_joueur.Bubble.y = 0
	 	Bubble_fixer_bubble()
	 	ExitFunction
	 EndIf
	 
      // Collisions avec d'autres tiles.
      
      Local i as Integer
      Local j as Integer
      
      For i=0 to Bubble_niveau.Colonnes-1
      	
      	For j=0 To Bubble_niveau.Rangees-1
      		
      		Local tile as Bubble_tile_type
      		
      		tile = Bubble_niveau.Tableau_tiles[i,j]
      		
      		If tile.Modele < 0
      			Continue
      		EndIf
      		
      		Local Coord as Bubble_coord_type
      		
      		Coord = Bubble_donner_coordonnees_tile (i,j)
      		
      		If Bubble_determiner_intersection_cercle (Bubble_joueur.Bubble.x + Bubble_niveau.Largeur_tile/2, Bubble_joueur.Bubble.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon, Coord.x + Bubble_niveau.Largeur_tile/2, Coord.y + Bubble_niveau.Hauteur_tile/2, Bubble_niveau.Rayon) = TRUE
				// Intersection avec uen bubble du niveau.
				Bubble_fixer_bubble()
				ExitFunction
			EndIf
			
		Next
		
	Next
	
EndFunction


Function Bubble_fixer_bubble()
	
	// Fixe la bubble sur la grille.
	
	Local CenterX as Integer
	Local CenterY as Integer
	Local GridPos as Bubble_coord_type
	
	// Donne la position sur la grille
	
	CenterX = Bubble_joueur.bubble.x + Bubble_niveau.Largeur_tile/2
	centerY = Bubble_joueur.bubble.y + Bubble_niveau.Hauteur_tile/2
		
	GridPos = Bubble_donner_position_grille (CenterX, CenterY)
	
	// S'assure que la position sur la grille est valide.
	
	If GridPos.x <= 0
		GridPos.x = 0
	Endif
	
	If GridPos.x >= Bubble_niveau.Colonnes
		GridPos.x = Bubble_niveau.Colonnes-1
	EndIf
	
	If GridPos.y <=  0
		GridPos.y = 0
	EndIf
	
	If GridPos.y >= Bubble_niveau.Rangees
		GridPos.y = Bubble_niveau.Rangees-1
	EndIf
	
     // Determine si la tile est vide
     
	Local bAjouterTile as Integer
	
	bAjouterTile = FALSE
	
	If Bubble_niveau.Tableau_tiles [Gridpos.x, Gridpos.y].Modele <> -1

		// Tile is not empty, shift the new tile downwards
		// La tile n'est pas vide, déplace la nouvelles tile au dessous.
		Local Nouvelle_rangee as Integer
		
		For 	Nouvelle_rangee = Gridpos.y+1 to Bubble_niveau.Rangees-1
			If Bubble_niveau.Tableau_tiles [GridPos.x, Nouvelle_rangee].Modele = -1
				Gridpos.y = Nouvelle_rangee
				bAjouterTile = TRUE
				Exit
			Endif
		Next
		
	Else
		
		bAjouterTile = TRUE
		
	EndIf
	
    // Ajoute la tile à la grille
    
    If bAjouterTile = TRUE
    	
    		// Cache la bubble du joueur.
    		Bubble_joueur.bubble.bVisible = FALSE
    		
    		// Définie la tile
    		Bubble_niveau.Tableau_tiles [GridPos.x,GridPos.y].Modele = Bubble_joueur.bubble.Modele
    		
	    	// Algorithme de detection d'une grappe.
	    	Bubble_trouver_grappe (GridPos.x,GridPos.y)
	    	
	    	// Efface les tiles de la grappe trouvée.
	    	Bubble_effacer_grappes_trouvees()
	    	
	    	// Efface les tiles flottantes
	    Bubble_effacer_tiles_flottantes()
	    	
	EndIf
	    	
	    	
	// Aucune grappe trouvée.
	
	Inc Bubble_compteur_tour,1
	
	If Bubble_compteur_tour >= BUBBLE_MAX_COMPTEUR_AJOUT_NOUVELLE_RANGEE
		
		// Ajoute une nouvelle rangées de tiles
		
		Bubble_ajouter_une_ligne_de_bubbles()
		Bubble_compteur_tour = 0
		Bubble_offset_rangee= Mod (Bubble_offset_rangee+1, 2)
		
		If Bubble_tester_gameover()
			ExitFunction
		EndIf
		
	EndIf
		
	// Re-affiche l'ensemble des tiles
	
	Bubble_reafficher_tiles()		
	
	// Prochaine bubble
	
	Bubble_prochaine_bubble()	
	Bubble_etat_jeu = JEU_PRET
	
EndFunction

Function Bubble_changer_etat (Colonne as Integer, Rangee as Integer, Etat as Integer)
	
	Bubble_niveau.Tableau_tiles [Colonne, Rangee].Etat = Etat
	
EndFunction

Global Tableau_traitement_tiles as Bubble_tile_type[]

Function Bubble_effacer_grappes_trouvees()
	
	Local i as Integer
	Local Colonne as Integer
	Local Rangee as Integer
	
	For i=0 To Tableau_traitement_tiles.length
		
		Colonne = Tableau_traitement_tiles[i].x
		Rangee = Tableau_traitement_tiles[i].y
		
		Bubble_niveau.Tableau_tiles[Colonne,Rangee].Modele = -1
		Bubble_niveau.Tableau_tiles[Colonne,Rangee].Etat = BUBBLE_ETAT_NORMAL
		
		If Bubble_debug_mode = TRUE
			If GetSpriteExists(Bubble_niveau.Tableau_tiles[Colonne,Rangee].Sprite_marque)
				DeleteSprite (Bubble_niveau.Tableau_tiles[Colonne,Rangee].Sprite_marque)
			EndIf
		EndIf
		
	Next
	
EndFunction

Function Bubble_marquer_voisins (Tableau_voisins_entree as Bubble_tile_type[], Modele_recherche as Integer)
	
	Local i as Integer
	Local Compteur as Integer
	
	Compteur = 0
	
	For i=0 To Tableau_voisins_entree.Length
			
		If Tableau_voisins_entree[i].Modele = Modele_recherche
			
			Tableau_traitement_tiles.Insert (Tableau_voisins_entree[i])
			
			Bubble_changer_Etat (Tableau_voisins_entree[i].x, Tableau_voisins_entree[i].y, BUBBLE_ETAT_DETECTEE)
			
			If Bubble_debug_mode = TRUE
				Bubble_marquer_tile (Tableau_voisins_entree[i].x, Tableau_voisins_entree[i].y, BUBBLE_ETAT_DETECTEE)
			EndIf
			
			Inc Compteur, 1
			
		EndIf
	Next	
	
EndFunction Compteur

Function Bubble_trouver_grappe (Tile_colonne as Integer, Tile_rangee as Integer)
	
	Local Tile_depart as Bubble_tile_type
	local Tile_courante as Bubble_tile_type
	
	Local Tableau_voisins as Bubble_tile_type[]
	Local Copie_tableau_voisins as Bubble_tile_type[]

	Local Compteur_modele_trouve as Integer
	Local Modele_recherche as Integer
	Local bSortie as Integer

	Bubble_changer_etat_tiles (BUBBLE_ETAT_NORMAL)
	
	Tableau_traitement_tiles.Length=-1
	
	Tile_depart = Bubble_niveau.Tableau_tiles [Tile_colonne, Tile_rangee]
	
	If Bubble_debug_mode = TRUE
		Bubble_marquer_tile (Tile_colonne, Tile_rangee, BUBBLE_ETAT_DEBUT)
	EndIf

	Modele_recherche = Bubble_joueur.Modele
	
	Tile_courante = Tile_depart
	
	Tableau_voisins = Bubble_donner_tiles_voisines (Tile_courante)	
	
	Compteur_modele_trouve = Bubble_marquer_voisins (Tableau_voisins, Modele_recherche)

	If Compteur_modele_trouve = 0
		ExitFunction
	Endif
	
	bSortie = FALSE
	
	While (bSortie = FALSE)
			
		If Tableau_voisins.Length > 0
			
			Copie_tableau_voisins = Tableau_voisins
			
			For i=0 To Copie_tableau_voisins.Length
				
				Tile_courante = Copie_Tableau_voisins[i]
				
				If Tile_courante.Modele = Modele_recherche
				
					Tableau_voisins = Bubble_donner_tiles_voisines(Tile_courante)
					Compteur_modele_trouve = Bubble_marquer_voisins (Tableau_voisins, Modele_recherche)
					
				Else
					
					bSortie = TRUE
					
				EndIf
				
			Next
			
		EndIf
		
		IF Compteur_modele_trouve = 0
			
			bSortie = TRUE
			
		EndIf
		
	EndWhile
	
EndFunction

Function Bubble_effacer_tiles_flottantes()
	
	Local Colonne as Integer
	Local Rangee as Integer
	
	For Colonne=0 To Bubble_niveau.Colonnes-1
		For Rangee=1 To Bubble_niveau.Rangees-1
			
			If Bubble_analyser_tile_voisines_en_haut (Bubble_niveau.Tableau_tiles[Colonne, Rangee]) = TRUE
							
				Bubble_niveau.Tableau_tiles[Colonne, Rangee].Modele = -1
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[Colonne, Rangee].Sprite) = TRUE
					DeleteSprite (Bubble_niveau.Tableau_tiles[Colonne, Rangee].Sprite)
				EndIf
				
				If Bubble_debug_mode = TRUE
					If GetSpriteExists(Bubble_niveau.Tableau_tiles[Colonne, Rangee].Sprite_marque)
						DeleteSprite(Bubble_niveau.Tableau_tiles[Colonne, Rangee].Sprite_marque)
					EndIf
				EndIf
				
			EndIf
			
		Next
	Next
	
EndFunction


Function Bubble_reafficher_tiles()
	
	Local i as Integer
	Local j as Integer
	
	Local Pos as Bubble_coord_type
	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_donner_coordonnees_tile (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1) 
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Pos.x,Pos.Y )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				SetSpriteFrame (Bubble_niveau.Tableau_tiles[i,j].Sprite,Bubble_niveau.Tableau_tiles[i,j].Modele+1)
				
				If Bubble_debug_mode = TRUE
				
					If GetSpriteExists (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
					
					Bubble_marquer_tile (i, j,Bubble_niveau.Tableau_tiles[i,j].Etat)
					
				EndIf
			
			Else
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				If Bubble_debug_mode = TRUE
					If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
				EndIf
			EndIf
			
		Next
		
	Next		
	
EndFunction

Function Bubble_tester_gameover()
	
	Local i as Integer
	Local Resultat as Integer
	
	For i=0 To Bubble_niveau.Colonnes-1
		
		// Determine s'il y a des bubbles dans la rangée du bas.
		
		If Bubble_niveau.Tableau_tiles[i,Bubble_niveau.Rangees-1].Modele <> -1
			
			// Game over
			Bubble_prochaine_bubble()
			Bubble_etat_jeu = JEU_GAMEOVER
			Resultat = TRUE
			SetTextString (Bubble_debug_message, "GAME OVER")
			ExitFunction Resultat
		EndIf
		
	Next
	
	Resultat = FALSE
	
EndFunction Resultat

Function Bubble_ajouter_une_ligne_de_bubbles()
	
	Local i as Integer
	Local j as Integer
	Local Modele as Integer
			
	
	Local Pos as Bubble_coord_type
	
	// Descend les rangées vers le bas.

	For i=0 To Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-2
			
			Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
						
			Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j].Modele = Bubble_niveau.Tableau_tiles[i, Bubble_niveau.Rangees-1-j-1].Modele
			
		Next
	Next
	
	
    // Ajoute une nouvelle rangée de bubble tout en haut des rangées.
    
    For i=0 To Bubble_niveau.Colonnes-1
    	
    		Modele = Bubble_donner_couleur_existante_aleatoire()
    		Bubble_niveau.Tableau_tiles[i,0].Modele = Modele
    		
    	Next
    	
    	// Efface toutes les tiles
    	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			If Bubble_niveau.Tableau_tiles[i,j].Modele <> -1
				
				Pos = Bubble_donner_coordonnees_tile (i,j)
				
				If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite)
					DeleteSprite(Bubble_niveau.Tableau_tiles[i,j].Sprite)
				EndIf
				
				If Bubble_debug_mode = TRUE
					If GetSpriteExists(Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
						DeleteSprite (Bubble_niveau.Tableau_tiles[i,j].Sprite_marque)
					EndIf
				EndIf
				
			EndIf
				
		Next
		
	Next
    	
    	
 EndFunction

Function Bubble_trouver_couleurs()
	
	// Troiuve les couleures restantes.
	
	Local FoundColors as Integer[]
	Local ColorTable as Integer[]
	
	Local i as Integer
	Local j as Integer
	
	Local Tile as Bubble_tile_type
	
	For i=0 to BUBBLE_MAX_COLOR-1
		ColorTable.Insert (FALSE)
	Next
	
	For i=0 to Bubble_niveau.Colonnes-1
		For j=0 to Bubble_niveau.Rangees-1
			Tile = Bubble_niveau.Tableau_tiles[i,j]
			If Tile.Modele >=0
				If ColorTable[Tile.Modele] = FALSE
					ColorTable[Tile.Modele] = TRUE
					FoundColors.Insert (Tile.Modele)
				EndIf
			EndIf	
		Next
	Next
	 
EndFunction FoundColors        


Function Bubble_changer_etat_tiles(Etat as Integer)
	
	// Reset the processed flags
	
	Local i as Integer
	Local j as Integer
	Local Index as Integer
	
	For i=0 to Bubble_niveau.Colonnes-1
		
		For j=0 To Bubble_niveau.Rangees-1
			
			Bubble_Niveau.Tableau_tiles[i,j].Etat = Etat
			
			If Bubble_debug_mode = TRUE
				If Bubble_Niveau.Tableau_tiles[i,j].Modele <> -1
					Bubble_marquer_tile (i,j, Etat)
				Endif
			Endif
		Next
		
	Next
	
EndFunction

Function Bubble_donner_tiles_voisines (Tile as Bubble_tile_type)
	
    // Get the neighbors of the specified tile
    
   Local i as Integer
	
   Local TileRow as Integer
   
   Tilerow = Mod(Tile.y + Bubble_offset_rangee,2)    
   
   Local Tableau_tiles_voisines as Bubble_tile_type[]
   
   Local Offset_voisins_x as Integer [6] 
   Local Offset_voisins_y as Integer [6]
   
   Local n_x as Integer 
   Local n_y as Integer
   
	Select TileRow
		
		Case 0

			Offset_voisins_x [0] = 1
			Offset_voisins_x [1] = 1
			Offset_voisins_x [2] = 0
			Offset_voisins_x [3] = -1
			Offset_voisins_x [4] = 0
			Offset_voisins_x [5] = 1
		
			Offset_voisins_y [0] = 0
			Offset_voisins_y [1] = 1
			Offset_voisins_y [2] = 1
			Offset_voisins_y [3] = 0
			Offset_voisins_y [4] = -1
			Offset_voisins_y [5] = -1
			
		EndCase		
		
		Case 1
	
			Offset_voisins_x [0] = 1
			Offset_voisins_x [1] = 0
			Offset_voisins_x [2] = -1
			Offset_voisins_x [3] = -1
			Offset_voisins_x [4] = -1
			Offset_voisins_x [5] = 0
		
			Offset_voisins_y [0] = 0
			Offset_voisins_y [1] = 1
			Offset_voisins_y [2] = 1
			Offset_voisins_y [3] = 0
			Offset_voisins_y [4] = -1
			Offset_voisins_y [5] = -1
		
		EndCase
		
	EndSelect
	
				
   // Get the neighbor offsets for the specified tile
   
    // Get the neighbors
    For i=0 to 5
    	
	    	Local Nx as Integer
	   	Local Ny as Integer
	   	
		Nx = Tile.x + Offset_voisins_x [i]   
		Ny = Tile.y + Offset_voisins_y [i]
		
	    // Make sure the tile is valid
	    If Nx >= 0
	    		If Nx <= Bubble_niveau.Colonnes
	    			If Ny >= 0 
	    				If  Ny <= Bubble_niveau.Rangees
	    					
	    					Tableau_tiles_voisines.Insert (Bubble_niveau.Tableau_tiles[nx,ny])
	    					
				    EndIf
				 EndIf
			Endif
		EndIf
	    	
	 Next
	 
EndFunction Tableau_tiles_voisines

Function Bubble_analyser_tile_voisines_en_haut (Tile as Bubble_tile_type)
	
    // Get the neighbors of the specified tile
    
   Local i as Integer
	
   Local TileRow as Integer
   
   Tilerow = Mod(Tile.y + Bubble_offset_rangee,2)    
   
   Local Offset_voisins_x as Integer [2] 
   Local Offset_voisins_y as Integer [2]
   
   Local n_x as Integer 
   Local n_y as Integer
   
	Select TileRow
		
		Case 0

			Offset_voisins_x [0] = 0
			Offset_voisins_x [1] = 1
		
			Offset_voisins_y [0] = -1
			Offset_voisins_y [1] = -1
			
		EndCase		
		
		Case 1
	
			Offset_voisins_x [0] = -1
			Offset_voisins_x [1] = 0
		
			Offset_voisins_y [0] = -1
			Offset_voisins_y [1] = -1
		
		EndCase
		
	EndSelect
	
    // Get the two top neighbors
    
    Local bVide = FALSE
    
    For i=0 to 1
    	
	    	Local Nx as Integer
	   	Local Ny as Integer
	   	
		Nx = Tile.x + Offset_voisins_x [i]   
		Ny = Tile.y + Offset_voisins_y [i]
		
	    // Make sure the tile is valid
	    If Nx >= 0
	    		If Nx <= Bubble_niveau.Colonnes
	    			If Ny >= 0 
	    				If  Ny <= Bubble_niveau.Rangees
	    					
	    					If Bubble_niveau.Tableau_tiles[nx,ny].Modele = -1
	    						bVide = TRUE
	    						Exit
	    					EndIf
				    EndIf
				 EndIf
			Endif
		EndIf
	    	
	 Next
	 
EndFunction bVide


Function Bubble_afficher_tiles()
	
	// Render tiles
	
	Local i as Integer
	Local j as Integer
	
	// Top to bottom
	For j=0 to Bubble_niveau.Rangees-1
		For i=0 To Bubble_niveau.Colonnes-1
			
			Local Tile as Bubble_tile_type
			
             // Get the tile
			Tile = Bubble_niveau.Tableau_tiles[i,j]

             // Calculate the tile coordinates
			Local Coord as Bubble_coord_type
			Coord = Bubble_donner_coordonnees_tile (i,j)
			
			// Check if there is a tile present
			If Tile.Modele >= 0
				
                 // Draw the tile
				Bubble_afficher_bubble (Tile, Coord.x, Coord.y, Tile.Modele)
				
			EndIf
			
		Next
	
	Next
	
EndFunction

Function Bubble_afficher_joueur()
	
	// Render the player bubble
	
	Local CenterX as Integer
	Local CenterY as Integer
	
	CenterX = Bubble_joueur.x + Bubble_niveau.Largeur_tile/2
	CenterY = Bubble_joueur.y + Bubble_niveau.Hauteur_tile/2
	
	// Draw the angle
	
	Local DestX as Integer
	Local DestY as Integer
	
	DestX = CenterX + 1.5 * Bubble_niveau.Largeur_tile * Cos (Bubble_joueur.Angle)
	DestY = CenterY + 1.5 * Bubble_niveau.Hauteur_tile * Sin (Bubble_joueur.Angle)
	
	DrawLine (CenterX, CenterY, DestX, DestY, 255,255,255)
	
	// Draw the next bubble
	Bubble_joueur.Prochaine_bubble.x = 800
	Bubble_joueur.Prochaine_bubble.y = 50
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.x, Bubble_joueur.Prochaine_bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_prochaine_bubble, Bubble_joueur.Prochaine_bubble.Modele+1)
	
	// Draw the bubble
	If Bubble_joueur.bubble.bVisible
			SetSpriteVisible (Bubble_joueur.Sprite_bubble, TRUE)
			SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
			SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	Else
		SetSpriteVisible (Bubble_joueur.Sprite_bubble, FALSE)
	EndIf
        
EndFunction 
    
Function Bubble_donner_coordonnees_tile (Colonne as Integer, Rangee as Integer)

	Local Tile as Bubble_coord_type
	
	Tile.x = Bubble_niveau.x + Colonne * Bubble_niveau.Largeur_tile
	
	// X offset pour les lignes paires ou impaires.
	If Mod(Rangee + Bubble_offset_rangee,2) = 0
		Inc Tile.x, Bubble_niveau.Largeur_tile/2
	EndIf
	
	Tile.y = Bubble_niveau.y + Rangee * Bubble_niveau.Hauteur_tile

EndFunction Tile

Function Bubble_donner_position_grille (x as Integer, y as Integer)
	
	Local Grille as Bubble_coord_type
	Local xOffset as Integer
	
	// Get the closest grid position
	
	// Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee ) Correction a Bubble_niveau.Hauteur_rangee-1
	Grille.y = Floor ( (y - Bubble_niveau.y) / Bubble_niveau.Hauteur_rangee-1 )
	
	xOffset = 0
	
	// Check for offset
	If Mod (Grille.y + Bubble_offset_rangee,2) = 0 
		xOffset = Bubble_niveau.Largeur_tile / 2
	EndIf
	
	Grille.x = Floor ( ((x - xOffset) - Bubble_niveau.x) / Bubble_niveau.Largeur_tile )
	
EndFunction Grille

Function Bubble_afficher_bubble (Tile as Bubble_tile_type, x as Integer, y as integer, Frame as Integer)
	 
    If Frame <0 or Frame >= BUBBLE_MAX_COLOR
    		ExitFunction
    	EndIf

    If GetSpriteExists (Tile.Sprite)
    		SetSpritePositionByOffset (Tile.Sprite, x, y)
    		SetSpriteFrame (Tile.Sprite, Frame+1)
    	Endif
    	
	If Bubble_debug_mode = TRUE
		If GetSpriteExists (Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].Sprite_marque)
			DeleteSprite (Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].Sprite_marque)
		EndIf
	
		Bubble_marquer_tile (Tile.x, Tile.y,Bubble_niveau.Tableau_tiles[Tile.x,Tile.y].Etat)
		
	Endif
	
EndFunction  
    	

Function Bubble_nouveau_jeu()

	Bubble_score = 0
	
	Bubble_compteur_tour = 0
	Bubble_offset_rangee= 0
	
	Bubble_etat_jeu = JEU_PRET
	
    Bubble_niveau_creer()
	
    // Initialise la prochaine bubble et affecte la tile actuelle.
    Bubble_prochaine_bubble()
    Bubble_prochaine_bubble()
    
EndFunction

Function Bubble_niveau_creer()

	Local i as Integer
	Local j as Integer
	
	Local Count as Integer
	
	Local RandomTile as Integer
	Local NewTile as Integer
	
	// Créé un niveau de tiles aléatoires.
	
	For j=0 to Bubble_niveau.Rangees-1
		
		
		RandomTile = Random (0, BUBBLE_MAX_COLOR-1)
		
		Count = 0
		
		For i=0 To Bubble_niveau.Colonnes-1
			
			If Count > 2
				
				// change la tile aléatoire
				
				NewTile = Random (0, BUBBLE_MAX_COLOR-1)
				
				// Vérifie bien que la nouvelle tile est bien différente de la précédente.
				
				If NewTile = RandomTile
					NewTile = Mod (NewTile + 1, BUBBLE_MAX_COLOR)
				Endif
				
				RandomTile = NewTile
				
				Count = 0
				
			EndIf
			
			Inc Count, 1
			
			If j < BUBBLE_NOMBRE_RANGEES_DEPART //Bubble_niveau.Rangees /2
				
				Bubble_niveau.Tableau_tiles[i,j].Modele = RandomTile
				
				Bubble_niveau.Tableau_tiles[i,j].Sprite = CreateSprite (Bubble_image)
				SetSpriteOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile/2, Bubble_niveau.Hauteur_tile/2)
				SetSpriteDepth (Bubble_niveau.Tableau_tiles[i,j].Sprite,1)
				SetSpritePositionByOffset (Bubble_niveau.Tableau_tiles[i,j].Sprite, i,j )
				SetSpriteAnimation (Bubble_niveau.Tableau_tiles[i,j].Sprite, Bubble_niveau.Largeur_tile, Bubble_niveau.Hauteur_tile, BUBBLE_MAX_COLOR)
				
				If Bubble_debug_mode = TRUE
					Bubble_marquer_tile (i,j, BUBBLE_ETAT_NORMAL)				
				EndIf
				
			Else
			
				Bubble_niveau.Tableau_tiles[i,j].Modele = -1
				
			Endif
			
		Next
		
	Next
		
EndFunction
			
Function Bubble_prochaine_bubble()
	
	// Crée une bubble alétoire pour le joueur.
		
    // Fixe le modèle de bubble.
 	
	Bubble_joueur.Modele = Bubble_joueur.Prochaine_bubble.Modele
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Prochaine_bubble.Modele
	
	
	Bubble_joueur.bubble.x = Bubble_joueur.x
	Bubble_joueur.bubble.y = Bubble_joueur.y
	
	SetSpritePositionByOffset (Bubble_joueur.Sprite_bubble, Bubble_joueur.bubble.x, Bubble_joueur.bubble.y)
	SetSpriteFrame (Bubble_joueur.Sprite_bubble, Bubble_joueur.Modele+1)
	
	Bubble_joueur.bubble.bVisible = TRUE
	
    // Donne une modele aléatoire parmi les couleurs possibles.

	Local NextColor as Integer
	
	Nextcolor = Bubble_donner_couleur_existante_aleatoire()
	
	// Initialise le modele de prochaine bubble.
	
	Bubble_joueur.Prochaine_bubble.Modele = NextColor		
	
EndFunction

Function Bubble_donner_couleur_existante_aleatoire()
	
    Local ExistingColors as Integer[]
    
    Existingcolors = Bubble_trouver_couleurs()
    
    Local Bubble_Modele as Integer
    
    BubbleType = 0
    
    If (Existingcolors.Length > 0)
    		Bubble_Modele = ExistingColors[Random (0, ExistingColors.Length-1)]
    	EndIf
    	
 EndFunction Bubble_Modele
    
Function Bubble_tirer_bubble()
	
	Bubble_joueur.Bubble.x = Bubble_joueur.x
	Bubble_joueur.Bubble.y = Bubble_joueur.y
	Bubble_joueur.Bubble.Angle = Bubble_joueur.Angle
	Bubble_joueur.Bubble.Modele = Bubble_joueur.Modele 
	
	Bubble_etat_jeu = JEU_TIRER_BUBBLE
	
EndFunction
    
Function Bubble_determiner_intersection_cercle (x1 as Integer, y1 as Integer, r1 as Integer, x2 as Integer, y2 as Integer, r2 as Integer)
	
	// Determine si l'intersection des deux cercles est vraie.
		
	Local Resultat as Integer
	
	Local dx as Integer
	Local dy as Integer
	Local Longueur as Integer
	
	// Calcule la distance entre les centres
	
	dx = x1 - x2
	dy = y1 - y2
	Longueur = sqrt (dx * dx + dy * dy)
	
	If Longueur < r1 + r2
		Resultat = TRUE 		// Intersection des cercles
	Else
		Resultat = FALSE
	EndIf
	
EndFunction Resultat

Function Bubble_gerer_souris()
	
	Local Pos as Bubble_coord_type
	
	Pos.x = GetRAWMouseX()
	Pos.y = GetRAWMouseY()
	
	Local MouseAngle as Integer
	
	MouseAngle = atan2 ( (Pos.y - Bubble_joueur.y+Bubble_niveau.Hauteur_tile/2), Pos.x - (Bubble_joueur.x + Bubble_niveau.Largeur_tile/2))
	
    // Conversion en angle de 0 à 360 degrees
	If (MouseAngle < 0)
		MouseAngle = 180 + (180 + MouseAngle)
	EndIf
	
	SetTextString (Bubble_debug_message, str(MouseAngle))
	
    // Restriction de l'angle 
    Local lbound as Integer
    Local ubound as Integer
     
    lbound = 200
    ubound = 340
     
     If MouseAngle < lbound
     	MouseAngle = lbound
 	Else
 		If MouseAngle > uBound
 			MouseAngle = uBound
 		Endif
 	Endif
 	
	Bubble_joueur.Angle = MouseAngle
	
	If GetRawMouseLeftPressed()
	
		If Bubble_etat_jeu = JEU_PRET
			Bubble_tirer_bubble()
		EndIf
		
	EndIf
	
	
EndFunction

// -------
//
// PROGRAMME PRINCIPAL
//
// -------


// ------------------------------------------------------------------------

// show all errors
SetErrorMode(2)

// set window properties
SetWindowTitle("Jeu_bubble_tir")
SetWindowSize(1024, 768, 0)
SetWindowAllowResize(1) // allow the user to resize the window

// set display properties
SetVirtualResolution(1024, 768) // doesn't have to match the window
SetOrientationAllowed(1, 1, 1, 1) // allow both portrait and landscape on mobile devices
SetSyncRate(30, 0) // 30fps instead of 60 to save battery
SetScissor(0, 0, 0, 0) // use the maximum available screen space, no black borders
UseNewDefaultFonts(1)

// ------------------------------------------------------------------------


Bubble_debug_mode = FALSE

Bubble_initialiser_jeu()
Bubble_nouveau_jeu()

do
	
	Bubble_jouer()
	
	//Print(ScreenFPS())
	Sync()
loop