P4ENGINE/p4.py

import random
  
  
class P4:

  def __init__(self,j1,j2,L,l):
  
    self.m=self.__matrice([],L,l)
    self.mp=(L,l)
    self.ordre=random.sample([[j1,1],[j2,2]],k=2)
    self.sig=True
    
    # Nouveau Joueur, Pion Joueur, Verification Pion, Changement Joueur
    self.stock=["NJ","PJ","VP","CJ"]
    self.state=[self.stock[0],(),"j1"]
    self.match=[True,""]
    
  # coeur du programme
  def update(self):
  
    if self.sig and self.match[0]:
    
      if self.stock[0]=="CJ":
        self.__inverse()
        
        if self.ordre[0][1]==1:
          self.state[2]="j1"
        else:
          self.state[2]="j2"
        
      elif self.stock[0]=="PJ":
        self.__placer()
        
      elif self.stock[0]=="VP":
        self.__detection()

      self.state[0]=self.stock[0]
      self.stock.append(self.stock.pop(0))
      
    else:
      pass
      
  def get_state(self):
    return self.state[0],self.state[1],self.state[2]
    
  def get_match(self):
    return self.match[0],self.match[1]
  
  def get_matrice(self):
    return self.m
  
  def pause(self,arg):
    self.sig=arg
    
  """ Fonctions privees """
  
  # place le pion et renvoie ses coordonnees
  def __placer(self):
    a=0
    x=self.ordre[0][0](self.m,self.ordre[0][1])
    
    # remet a la derniere colonne si x est trop grand
    if x>=self.mp[1]:
      x=self.mp[1]-1
      
    for i in range(self.mp[0]):

      if self.m[i][x]==0:
        a+=1
        
      else:
        break
    if self.m[a-1][x]!=0 and a==0:
      pass
    else:
      self.m[a-1][x],self.state[1]=self.ordre[0][1],(a-1,x)
  
  # inverse l'ordre des joueurs
  def __inverse(self):
    self.ordre[0],self.ordre[1]=self.ordre[1],self.ordre[0]
    
  # creer une matrice
  def __matrice(self,m,y,x):
    for i in range(y):
        m.append([])
        for j in range(x):
            m[i].append(0)
    return m
    
  def __detection(self):
    #---------------Detection en ligne------------------
    ligne=[]
    ligne_str=""
    for ele in self.m[self.state[1][0]]:
        ligne.append(str(ele))
    ligne_str=ligne_str.join(ligne) #transformation de la liste en str pour utiliser in
    if "1111" in ligne_str:
        self.match[1]="J1"
        self.match[0]=False
    if "2222" in ligne_str:
        self.match[1]="J2"
        self.match[0]=False
    #---------------Detection en colonne-----------------
    colonne=[]
    for ele in self.m: #boucle recuperant la colonne du pion
        colonne.append(str(ele[self.state[1][1]]))
    colonne_str=""
    colonne_str=colonne_str.join(colonne) #transformation de la liste en str pour utiliser in
    if "1111" in colonne_str:
        self.match[1]="J1"
        self.match[0]=False
    if "2222" in colonne_str:
        self.match[1]="J2"
        self.match[0]=False
    #-----------Detection en diagonale de gauche a droite-----------
    i=self.state[1][0]
    j=self.state[1][1]
    cpt=0 #Compteur incrementer pour chaque pion successif du joueur sur la diagonale
    while i>=0 and j>=0 and i<self.mp[0] and j<self.mp[1]: #parcourt des antecedents du pion sur la diagonale pour detecter une diagonale gagnante
        if self.m[i][j]!=self.m[self.state[1][0]][self.state[1][1]]:
            break
        cpt=cpt+1
        i=i-1
        j=j-1
    i=self.state[1][0]
    j=self.state[1][1]
    while i>=0 and j>=0 and i<self.mp[0] and j<self.mp[1]: #parcourt des successeur du pion sur la diagonale pour detecter une diagonale gagnante
        if self.m[i][j]!=self.m[self.state[1][0]][self.state[1][1]]:
            break
        cpt=cpt+1
        i=i+1
        j=j+1
    if cpt>=5:
        self.match[1]="J"+str(self.m[self.state[1][0]][self.state[1][1]])
        self.match[0]=False
    #-----------Detection en diagonale de droite a gauche-----------
    i=self.state[1][0]
    j=self.state[1][1]
    cpt=0
    while i>=0 and j>=0 and i<self.mp[0] and j<self.mp[1]: #parcourt des antecedents du pion sur la diagonale pour detecter une diagonale gagnante
        if self.m[i][j]!=self.m[self.state[1][0]][self.state[1][1]]:
            break
        cpt=cpt+1
        i=i+1
        j=j-1
    i=self.state[1][0]
    j=self.state[1][1]
    while i>=0 and j>=0 and i<self.mp[0] and j<self.mp[1]: #parcourt des successeur du pion sur la diagonale pour detecter une diagonale gagnante
        if self.m[i][j]!=self.m[self.state[1][0]][self.state[1][1]]:
            break
        cpt=cpt+1
        i=i-1
        j=j+1
    if cpt>=5:
        self.match[1]="J"+str(self.m[self.state[1][0]][self.state[1][1]])
        self.match[0]=False
    #--------------Detection degalite---------------
    if self.match[0]:
      cpt=0
      for i in range(7):
          lig = 0 # Variable ligne
          if self.m[0][i] != 0:
                cpt=cpt+1
      if cpt>=7:
          self.match[1]="Egalite"
          self.match[0]=False
    #----------------Aucune detection----------------
    else:
        pass