# data[].attributes.body
l'instruction break vous donne la possibilité de quitter une boucle au moment où une condition externe est déclenchée.

# data[].attributes.body
Scrum master

# data[].attributes.body
Product Owner

# data[].attributes.body
création de 2 joueurs

# data[].attributes.body
Dévelopeur

# data[].attributes.body
création de souris pour déplacer les pions

# data[].attributes.body
création de l'interface du damier , bibliothèque pygame etc

# data[].attributes.body
création et changement d'un pion devenant une dame sous certaines conditions

# data[].attributes.body
Le programme contient :
- plusieurs classes : l’objectif est que chaque élève du groupe ait programmé au moins une
des classes du programme
- utiliser la strucure de pile ou de file dans le programme.
- une interface graphique (Tkinter ou autre) sous forme de classe.
- une structure claire et des docstrings.
- "de la programmation défensive avec des assert "

# data[].attributes.body
création des 20 pions "blanc" et "noirs"(MODIFIER...)

# data[].attributes.body
coordonnées des pions dans le damier en 2D

# data[].attributes.body
BONUS A PARTIR DE LA BASE DES .PY
UTILISATION DE PILE OU FILE

# data[].attributes.body
"Pour Travail maison faire
pip install pylint dans le bloc de commande
pour avoir la vérification Linter"

# data[].attributes.body
Il est nécessaire de faire pip install pygame_menu
en vue de créer un menu directement en relation avec pygame , bibliothèque etc

# data[].attributes.body
"De la même manière
pip install autopep8 dans le bloc de commande
pour avoir l'aide du guide Pep8"

# data[].attributes.body
Nous nous sommes en partie aidés de plusieurs sites de présentations afin d'avoir un code optimal pour déplacer nous pions etc...

# data[].attributes.attachment_link.description
Dans ce projet nous allons tenter de créer un jeu du morpion ( article sur Wikipédia sur le jeu du morpion si nécessaire) à l’aide de la bibliothèque Pygame.

# data[].attributes.attachment_link.readable_text
Documents

Basic information about pygame: what it is, who is involved, and where to find it.

Steps needed to compile pygame on several platforms. Also help on finding and installing prebuilt binaries for your system.

File Path Function Arguments

How pygame handles file system paths.

LGPL License

This is the license pygame is distributed under. It provides for pygame to be distributed with open source and commercial software. Generally, if pygame is not changed, it can be used with any type of program.

Tutorials

Introduction to Pygame

An introduction to the basics of pygame. This is written for users of Python and appeared in volume two of the Py magazine.

The beginning steps on importing and initializing pygame. The pygame package is made of several modules. Some modules are not included on all platforms.

A basic tutorial that covers the concepts behind 2D computer animation. Information about drawing and clearing objects to make them appear animated.

Chimp Tutorial, Line by Line

The pygame examples include a simple program with an interactive fist and a chimpanzee. This was inspired by the annoying flash banner of the early 2000s. This tutorial examines every line of code used in the example.

Sprite Module Introduction

Pygame includes a higher level sprite module to help organize games. The sprite module includes several classes that help manage details found in almost all games types. The Sprite classes are a bit more advanced than the regular pygame modules, and need more understanding to be properly used.

Surfarray Introduction

Pygame used the NumPy python module to allow efficient per pixel effects on images. Using the surface arrays is an advanced feature that allows custom effects and filters. This also examines some of the simple effects from the pygame example, arraydemo.py.

Camera Module Introduction

Pygame, as of 1.9, has a camera module that allows you to capture images, watch live streams, and do some basic computer vision. This tutorial covers those use cases.

A list of thirteen helpful tips for people to get comfortable using pygame.

A large tutorial that covers the bigger topics needed to create an entire game.

Getting a display surface for the screen.

# data[].attributes.attachment_link.title
Pygame Front Page - pygame v2.0.1.dev1 documentation

# data[].attributes.attachment_link.description
Basic information about pygame: what it is, who is involved, and where to find it. Steps needed to compile pygame on several platforms. Also help on finding and installing prebuilt binaries for your system. File Path Function Arguments How pygame handles file system paths. LGPL License This is the license pygame is distributed under.

# data[].attributes.body
-créer un dossier principal nommé "ProjetNsi"
-dans ce dossier recréer un dossier Images et y mettre les cinq photos
-créer un dossier Son avec les deux  musique
-dans le dossier ProjetNsi mettre les 5    .py

# data[].attributes.body
utiliser un python 3.9
et un pygame relié à cette version par l'usage classique du pip dans le shell "(version utilisé pour nous 2.1.2)"

# data[].attributes.body
Il est nécessaire de faire
pip install screeninfo

# data[].attributes.body
quand le jeu se finit appuyer sur n'importe quelle touche pour fermer le programme

# data[].attributes.body
On a rajouté une variable qui est capable de remplacer un changement en roi (= dame) par un changement en fou avec une faible probabilité ; en contrepartie de la faible chance de se produire celui-ci à des déplacement beaucoup plus aléatoire (s'adaptant à différentes combinaison de positions)qu'un roi classique rendant la partie plus pimenté !

# data[].attributes.attachment_link.readable_text
from parametre import *
import pygame

class Piece:
    PADDING = 15
    OUTLINE = 2

    def __init__(self, row, col, color):
        """Initialisation"""
        self.row = row
        self.col = col
        self.color = color
        self.king = False
        self.fool = False
        self.x = 0
        self.y = 0
        self.calc_pos()

    def calc_pos(self):
        """Calculer la position"""
        self.x = SQUARE_SIZE * self.col + SQUARE_SIZE // 2
        self.y = SQUARE_SIZE * self.row + SQUARE_SIZE // 2

    def make_king(self):
        """Rendre roi"""
        self.king = True

    def make_fool(self):
        """Rendre fou"""
        self.fool = True

    def draw(self, win):
        """Dessine une pièce"""
        radius = SQUARE_SIZE//2 - self.PADDING
        pygame.draw.circle(win, GREY, (self.x, self.y), radius + self.OUTLINE)
        pygame.draw.circle(win, self.color, (self.x, self.y), radius)
        if self.king:
            win.blit(COURONNE, (self.x - COURONNE.get_width()//2, self.y - COURONNE.get_height()//2))
        if self.fool:
            win.blit(FOU, (self.x - FOU.get_width()//2, self.y - FOU.get_height()//2))

    def move(self, row, col):
        """Déplacer une pièce"""
        self.row = row
        self.col = col
        self.calc_pos()

    def __repr__(self):
        return str(self.color)

# data[].attributes.attachment_link.readable_text
import pygame
from parametre import *
from plateauAll import Plateau

class Game:
    """Classe représentant le jeu et les différentes actions faites au cours du jeu"""

    def __init__(self, win):
        """Initialisation de la classe (constructeur)"""
        self._init()
        self.win = win

    def update(self):
        """Mise à jour"""
        self.board.draw(self.win)
        self.draw_valid_moves(self.valid_moves)
        pygame.display.update()

    def _init(self):
        """Re-Initialisation"""
        self.selected = None
        self.board = Plateau()
        self.turn = WHITE
        self.valid_moves = {}

    def winner(self):
        """Le gagnant"""
        return self.board.winner()

    def reset(self):
        self._init()

    def select(self, row, col):
        """Selectionner une case """
        if self.selected:
            result = self._move(row, col)
            if not result:
                self.selected = None
                self.select(row, col)

        piece = self.board.get_piece(row, col)
        if piece != 0 and piece.color == self.turn:
            self.selected = piece
            self.valid_moves = self.board.get_valid_moves(piece)
            return True

        return False

    def _move(self, row, col):
        """Déplacer une pièce"""
        piece = self.board.get_piece(row, col)
        if self.selected and piece == 0 and (row, col) in self.valid_moves:
            self.board.move(self.selected, row, col)
            skipped = self.valid_moves[(row, col)]
            if skipped:
                self.board.remove(skipped)
            self.change_turn()
        else:
            return False

        return True

    def draw_valid_moves(self, moves):
        """Dessine les mouvements valides"""
        for move in moves:
            row, col = move
            pygame.draw.circle(self.win, BLUE, (col * SQUARE_SIZE + SQUARE_SIZE//2, row * SQUARE_SIZE + SQUARE_SIZE//2), 15)

    def change_turn(self):
        """Changer le tour"""
        self.valid_moves = {}
        if self.turn == RED:
            self.turn = WHITE
        else:
            self.turn = RED

    def get_board(self):
            return self.board

# data[].attributes.attachment_link.readable_text
from screeninfo import get_monitors
import pygame

screen = get_monitors()[0]
#Pour la fluidité du jeu
FPS = 60

HEIGHT,WIDTH=800, 800


#Nombre de Lignes et de Colonnes
ROWS, COLS = 8, 8

#Longueur de la case
SQUARE_SIZE=WIDTH//COLS

#Représentation des couleurs
RED = (255, 8, 0)
WHITE = (255, 255, 255)
BLACK = (36, 36, 36)
BLUE = (115, 194, 251)
GREY = (128,128,128)
BEER = (255, 151, 28)
ALMOND = (255, 235, 205)
#La couronne quand une pièce atteint le territoire de l'adversaire
COURONNE= pygame.transform.scale(pygame.image.load('Images/couronne.png'), (44, 25))
FOU= pygame.transform.scale(pygame.image.load('Images/Fou.png'), (44, 25))

# data[].attributes.body
création du menu et des écrans de fin

# data[].attributes.attachment_link.readable_text
from turtle import *




def carre(n):
    for i in range(4):
        forward(n)
        left(90)


def deplacer(e):
    up()
    forward(e)
    left(90)
    forward(e)
    right(90)
    down()



def carres_emboites(n):
    if n == 5:
        carre(5)
    else:
        carre(n)
        deplacer(5)
        carres_emboites(n-5)

carres_emboites(4)

# data[].attributes.attachment_link.readable_text

def factorielle(n):
    if n==1:
        return n
    else:
        return n*factorielle(n-1)
print(factorielle(4))



# data[].attributes.attachment_link.readable_text
from turtle import *

def spirale(cote, delta, angle, n) :
    if(n>0) :
        forward(cote)
        right(angle)
        spirale(cote + delta, delta ,angle, n-1)


hideturtle()
"""spirale(10, 5 , 90, 30)
exitonclick()"""
speed(100)
spirale(10, 1, 798, 300)
exitonclick()

# data[].attributes.body
Allan Khebab To4 Activité : la modélisation de climat demain

Question 1 :

un modèle climatique cherche à représenter au mieux les forces qui induisent les mouvements atmosphériques, océaniques ou terrestres. Pour cela, le modèle part de conditions initiales des variables climatiques telles que le vent, la température, le rayonnement, l’humidité… et les fait évoluer en résolvant les équations mathématiques.Les modèles climatiques sont des systèmes d'équations différentielles , pour produire un modèle, on divise la planète en une grille tridimensionnelle, appliquent les équations de base et évaluent les résultats.

Question 2 : D’après le document B et C je vois la pertinence d’un modèle climatique

est évaluée sur plusieurs paramètre tel que la variabilité de température mit en

comparaison avec plusieurs scénarios de croissance économique , on confronte des

résultats de la simulation aux différentes observations