Skip to content

🧠 Langage Kod - Documentation Complète

Le langage Kod est un langage de programmation simplifié conçu spécifiquement pour l'apprentissage de la programmation à travers la création de jeux 2D.

📋 Table des Matières

  1. Philosophie du Langage
  2. Syntaxe de Base
  3. Variables et Types
  4. Structures de Contrôle
  5. Fonctions
  6. API Graphique
  7. Gestion des Entrées
  8. Exemples Pratiques
  9. Bonnes Pratiques

Philosophie

Qu'est-ce que Kod ?

Kod est un langage de script inspiré de Python, LUA et Pascal, conçu pour :

✅ Simplicité : Syntaxe épurée, pas de point-virgules
✅ Lisibilité : Structure claire avec end explicites
✅ Accessibilité : Idéal pour les débutants
✅ Immédiat : Résultats visuels instantanés
✅ Ludique : Orienté création de jeux

Compilation Automatique

Kod est transpilé automatiquement en JavaScript ES6 :

// Code Kod
let speed = 5
function update()
    x = x + speed
end

// JavaScript généré
class KodGame {
    constructor(emulator) {
        this.speed = 5;
    }

    update() {
        this.x = this.x + this.speed;
    }
}

Syntaxe de Base

Structure d'un Programme

// === VARIABLES GLOBALES ===
let playerX = 200
let playerY = 150
let score = 0

// === FONCTION DE DÉMARRAGE ===
function start()
    clearScreen("#000033")
    drawText("Jeu démarré!", 100, 50, "#FFFFFF")
end

// === BOUCLE PRINCIPALE ===
function update()
    // Effacer l'écran
    clearScreen("#000033")

    // Logique du jeu
    if isKeyPressed("left")
        playerX = playerX - 3
    end

    // Affichage
    drawCircle(playerX, playerY, 15, "#FF6600")
    drawText("Score: " + score, 10, 20, "#FFFFFF")
end

Règles Syntaxiques

1. Commentaires

// Commentaire sur une ligne
// Les commentaires sont ignorés par le compilateur

let x = 100  // Commentaire en fin de ligne

2. Casse et Nommage

// Variables : camelCase recommandé
let playerSpeed = 5
let enemyCount = 3
let isGameOver = false

// Fonctions : camelCase obligatoire
function updatePlayer()
    // ...
end

function checkCollision()
    // ...
end

3. Indentation

  • Recommandée : 4 espaces
  • Flexible : Tabs acceptés
  • Important : Cohérence dans tout le code

4. Blocs de Code

// Toujours terminer les blocs par 'end'
if condition
    // instructions
end

function maFonction()
    // instructions
end

for i = 1 to 10
    // instructions
end

Variables et Types

Déclaration de Variables

// Déclaration avec valeur initiale
let x = 100
let y = 200
let name = "Player"
let isAlive = true

// Variables numériques
let speed = 2.5
let angle = 3.14159
let health = 100

// Variables texte (chaînes)
let title = "Mon Jeu"
let message = "Game Over"

// Variables booléennes
let gameStarted = false
let hasKey = true

Types Supportés

1. Nombres

let entier = 42          // Nombre entier
let decimal = 3.14       // Nombre décimal
let negatif = -10        // Nombre négatif
let grand = 1000000      // Grand nombre

2. Chaînes de Caractères

let simple = "Hello"
let guillemets = 'World'
let phrase = "Bonjour le monde!"
let vide = ""

// Concaténation avec +
let complet = "Score: " + score
let coordonnees = "Position (" + x + ", " + y + ")"

3. Booléens

let vrai = true
let faux = false

// Résultats de comparaisons
let estGrand = (x > 100)
let estEgal = (score == 0)

Opérations sur Variables

Arithmétiques

let a = 10
let b = 3

let somme = a + b        // 13
let difference = a - b   // 7
let produit = a * b      // 30
let quotient = a / b     // 3.33...
let modulo = a % b       // 1 (reste)

Comparaisons

let x = 5
let y = 10

// Égalité
x == y    // false
x != y    // true

// Ordre
x < y     // true
x > y     // false
x <= 5    // true
x >= 10   // false

Logiques

let a = true
let b = false

// ET logique
a && b    // false

// OU logique  
a || b    // true

// NON logique
!a        // false
!b        // true

Structures de Contrôle

Conditions (if/else)

Syntaxe Simple

if condition
    // instructions si vrai
end

Avec Alternative

if playerHealth > 0
    drawCircle(playerX, playerY, 20, "#00FF00")
else
    drawText("GAME OVER", 150, 150, "#FF0000")
end

Conditions Multiples

if score < 100
    drawText("Débutant", 10, 10, "#YELLOW")
else if score < 500
    drawText("Intermédiaire", 10, 10, "#ORANGE")
else if score < 1000
    drawText("Avancé", 10, 10, "#RED")
else
    drawText("Expert!", 10, 10, "#GOLD")
end

Conditions Complexes

// Plusieurs conditions avec ET
if (playerX > 0) && (playerX < 400) && (playerY > 0) && (playerY < 300)
    // Joueur dans les limites
end

// Plusieurs conditions avec OU
if isKeyPressed("space") || isKeyPressed("enter")
    // Tir ou validation
end

// Négation
if !gameOver && !isPaused
    // Continuer le jeu
end

Boucles

Boucle For Simple

// Compter de 1 à 10
for i = 1 to 10
    drawCircle(i * 30, 100, 10, "#FF0000")
end

Boucle For avec Pas

// Compter de 0 à 100 par pas de 10
for x = 0 to 100 step 10
    drawLine(x, 0, x, 300, "#333333")
end

Boucle While

let x = 0
while x < 400
    drawPixel(x, 150, "#FFFFFF")
    x = x + 5
end

Exemples Pratiques de Boucles

// Dessiner une grille
for x = 0 to 400 step 20
    for y = 0 to 300 step 20
        drawPixel(x, y, "#444444")
    end
end

// Afficher plusieurs ennemis
for i = 1 to 5
    let enemyX = i * 70
    drawRect(enemyX, 200, 20, 20, "#FF0000")
end

// Animation de particules
let particleX = 0
while particleX < 400
    drawCircle(particleX, 150, 3, "#FFFF00")
    particleX = particleX + 8
end

Fonctions

Structure des Fonctions

Fonctions Obligatoires

function start()
    // Appelée UNE FOIS au démarrage du jeu
    // Initialisation, écran de démarrage
    clearScreen("#000000")
    drawText("Initialisation...", 100, 150, "#FFFFFF")
end

function update()
    // Appelée CHAQUE FRAME (60 fois par seconde)
    // Logique principale du jeu
    clearScreen("#000033")

    // Mise à jour des objets
    updatePlayer()
    updateEnemies()

    // Affichage
    drawPlayer()
    drawEnemies()
    drawUI()
end

Fonctions Personnalisées

// Fonction sans paramètres
function resetGame()
    playerX = 200
    playerY = 150
    score = 0
    gameOver = false
end

// Fonction avec logique
function updatePlayer()
    if isKeyPressed("left")
        playerX = playerX - playerSpeed
    end
    if isKeyPressed("right") 
        playerX = playerX + playerSpeed
    end

    // Limites de l'écran
    if playerX < 0
        playerX = 0
    end
    if playerX > 380
        playerX = 380
    end
end

// Fonction d'affichage
function drawPlayer()
    drawRect(playerX, playerY, 20, 20, "#00FF00")

    if hasShield
        drawCircle(playerX + 10, playerY + 10, 25, "#0066FF")
    end
end

Organisation du Code

Structure Recommandée

// === VARIABLES GLOBALES ===
let playerX = 200
let playerY = 150
let enemies = []
let score = 0

// === FONCTION PRINCIPALE ===
function start()
    initializeGame()
end

function update()
    handleInput()
    updateGame()
    renderGame()
end

// === FONCTIONS D'INITIALISATION ===
function initializeGame()
    clearScreen("#001122")
    createEnemies()
    showStartMessage()
end

// === FONCTIONS DE LOGIQUE ===
function handleInput()
    if isKeyPressed("left")
        movePlayerLeft()
    end
    if isKeyPressed("right")
        movePlayerRight()
    end
end

function updateGame()
    updatePlayer()
    updateEnemies()
    checkCollisions()
end

// === FONCTIONS D'AFFICHAGE ===
function renderGame()
    clearScreen("#001122")
    drawBackground()
    drawPlayer()
    drawEnemies()
    drawUI()
end

API Graphique

Gestion de l'Écran

Nettoyage

// Effacer tout l'écran avec une couleur
clearScreen("#000000")      // Noir
clearScreen("#FFFFFF")      // Blanc  
clearScreen("#003366")      // Bleu foncé
clearScreen("#RGB")         // Format hexadécimal

Formes Géométriques

Rectangles

// Rectangle plein
drawRect(x, y, width, height, color)
drawRect(100, 50, 80, 40, "#FF0000")

// Exemples
drawRect(0, 0, 400, 20, "#333333")        // Barre supérieure
drawRect(playerX, playerY, 20, 20, "#00FF00")  // Joueur carré

Cercles

// Cercle plein
drawCircle(x, y, radius, color)
drawCircle(200, 150, 25, "#FFFF00")

// Exemples  
drawCircle(ballX, ballY, ballRadius, "#FFFFFF")  // Balle
drawCircle(mouseX, mouseY, 5, "#FF0000")         // Curseur

Lignes

// Ligne droite
drawLine(x1, y1, x2, y2, color)
drawLine(0, 150, 400, 150, "#666666")

// Exemples
drawLine(0, 0, 400, 300, "#FFFFFF")      // Diagonale
drawLine(playerX, playerY, targetX, targetY, "#FF0000")  // Visée

Pixels

// Point unique
drawPixel(x, y, color)
drawPixel(200, 150, "#FFFFFF")

// Utile pour les effets
for i = 1 to 100
    drawPixel(randomX, randomY, "#FFFF00")  // Étoiles
end

Texte et Interface

Affichage de Texte

// Texte simple
drawText(text, x, y, color)
drawText("Score: 1250", 10, 20, "#FFFFFF")

// Exemples d'interface
drawText("GAME OVER", 150, 150, "#FF0000")
drawText("Niveau " + currentLevel, 10, 40, "#FFFF00")
drawText("Vies: " + lives, 10, 60, "#00FF00")
drawText("Temps: " + timeRemaining, 300, 20, "#CYAN")

Couleurs

Formats Supportés

// Hexadécimal (recommandé)
"#FF0000"    // Rouge pur
"#00FF00"    // Vert pur  
"#0000FF"    // Bleu pur
"#FFFFFF"    // Blanc
"#000000"    // Noir
"#808080"    // Gris

// Couleurs nommées (limitées)
"red"        // Rouge
"green"      // Vert
"blue"       // Bleu
"yellow"     // Jaune
"white"      // Blanc
"black"      // Noir

Palette Recommandée

// Couleurs de jeu classiques
let colorBackground = "#001122"    // Bleu très foncé
let colorPlayer = "#00FF00"        // Vert vif
let colorEnemy = "#FF0000"         // Rouge vif
let colorUI = "#FFFFFF"           // Blanc
let colorPowerup = "#FFFF00"      // Jaune
let colorBorder = "#666666"       // Gris moyen

Sons et Audio

Jouer des Sons

// Jouer une note musicale
playSound(note, durée)
playSound("do", 0.3)     // Note do pendant 0.3 secondes
playSound("re", 0.5)     // Note ré pendant 0.5 secondes

// Notes disponibles
playSound("do", 0.2)     // Do (C4 - 261.63 Hz)
playSound("re", 0.2)     // Ré (D4 - 293.66 Hz)  
playSound("mi", 0.2)     // Mi (E4 - 329.63 Hz)
playSound("fa", 0.2)     // Fa (F4 - 349.23 Hz)
playSound("sol", 0.2)    // Sol (G4 - 392.00 Hz)
playSound("la", 0.2)     // La (A4 - 440.00 Hz)
playSound("si", 0.2)     // Si (B4 - 493.88 Hz)
playSound("do2", 0.2)    // Do aigu (C5 - 523.25 Hz)

Exemples d'Usage Audio

// Effet sonore de saut
if isKeyPressed("up") && onGround
    playerY = playerY - jumpPower
    playSound("do", 0.1)  // Petit bip de saut
end

// Mélodie de victoire
function playVictoryMelody()
    playSound("do", 0.2)
    playSound("mi", 0.2)  
    playSound("sol", 0.4)
end

// Son d'erreur/dégât
if collision
    playSound("si", 0.1)   // Note aigue pour l'alerte
end

// Séquence musicale simple
let melodyStep = 0
let melodyNotes = ["do", "re", "mi", "do"]

if frameCount % 30 == 0  // Chaque demi-seconde
    playSound(melodyNotes[melodyStep], 0.2)
    melodyStep = melodyStep + 1
    if melodyStep >= 4
        melodyStep = 0
    end
end

Paramètres Audio

// Durée par défaut : 0.2 seconde
playSound("do")          // Équivaut à playSound("do", 0.2)

// Durées recommandées
playSound("do", 0.1)     // Son court (effet)
playSound("re", 0.3)     // Son moyen (action)
playSound("mi", 0.5)     // Son long (mélodie)
playSound("fa", 1.0)     // Son très long (ambiance)

Notes techniques : - Les sons sont générés par oscillateur (pas de fichiers audio) - Type d'onde : square (son rétro 8-bit) - Volume automatiquement ajusté avec fade-out - Nécessite une interaction utilisateur pour initialiser l'audio

Gestion des Entrées

Détection des Touches

Fonction Principale

isKeyPressed(keyName)   // Retourne true/false

Touches Supportées

// Flèches directionnelles
isKeyPressed("up")      // Flèche Haut ou W
isKeyPressed("down")    // Flèche Bas ou S  
isKeyPressed("left")    // Flèche Gauche ou A
isKeyPressed("right")   // Flèche Droite ou D

// Espace
isKeyPressed("space")   // Barre d'espace

Exemples de Contrôles

Mouvement Basique

function update()
    // Mouvement du joueur
    if isKeyPressed("left")
        playerX = playerX - playerSpeed
    end
    if isKeyPressed("right")
        playerX = playerX + playerSpeed
    end
    if isKeyPressed("up")
        playerY = playerY - playerSpeed
    end
    if isKeyPressed("down")
        playerY = playerY + playerSpeed
    end
end

Mouvement avec Limites

function updatePlayer()
    let oldX = playerX
    let oldY = playerY

    // Tentative de mouvement
    if isKeyPressed("left")
        playerX = playerX - playerSpeed
    end
    if isKeyPressed("right")
        playerX = playerX + playerSpeed
    end

    // Vérification des limites
    if playerX < 0
        playerX = 0
    end
    if playerX > 380  // 400 - largeur joueur (20)
        playerX = 380
    end
end

Actions Spéciales

function handleActions()
    // Tir avec espace
    if isKeyPressed("space")
        if canShoot
            createBullet(playerX + 10, playerY)
            canShoot = false
            shootCooldown = 10
        end
    end

    // Gestion du cooldown
    if shootCooldown > 0
        shootCooldown = shootCooldown - 1
    end
    if shootCooldown == 0
        canShoot = true
    end
end

Contrôles de Jeu

function handleGameControls()
    // Pause/Reprise
    if isKeyPressed("space") && gameStarted && !gamePaused
        gamePaused = true
    else if isKeyPressed("space") && gamePaused
        gamePaused = false
    end

    // Redémarrage
    if isKeyPressed("space") && gameOver
        restartGame()
    end
end

Exemples Pratiques

1. Animation Simple

let x = 0
let direction = 1

function start()
    clearScreen("#000033")
end

function update()
    clearScreen("#000033")

    // Animation rebond
    x = x + (direction * 3)
    if x > 380 || x < 0
        direction = direction * -1
    end

    drawCircle(x, 150, 20, "#FF6600")
end

2. Collecteur d'Objets

let playerX = 200
let playerY = 250
let coinX = 100
let coinY = 100
let score = 0

function start()
    clearScreen("#001122")
end

function update()
    clearScreen("#001122")

    // Contrôles joueur
    if isKeyPressed("left")
        playerX = playerX - 3
    end
    if isKeyPressed("right")
        playerX = playerX + 3
    end

    // Collision avec pièce
    let distance = (playerX - coinX) * (playerX - coinX) + (playerY - coinY) * (playerY - coinY)
    if distance < 400  // 20*20 pixels de distance
        score = score + 10
        // Nouvelle position aléatoire pour la pièce
        coinX = 50 + (score % 300)
        coinY = 50 + ((score * 3) % 200)
    end

    // Affichage
    drawRect(playerX - 10, playerY - 10, 20, 20, "#00FF00")  // Joueur
    drawCircle(coinX, coinY, 8, "#FFFF00")                   // Pièce
    drawText("Score: " + score, 10, 20, "#FFFFFF")           // Interface
end

3. Jeu de Tir Simple

let playerX = 200
let bullets = []
let enemies = []
let score = 0

function start()
    // Créer quelques ennemis
    for i = 1 to 5
        // enemies[i] sera géré inline dans update()
    end
end

function update()
    clearScreen("#000033")

    // Contrôles joueur
    if isKeyPressed("left") && playerX > 0
        playerX = playerX - 4
    end
    if isKeyPressed("right") && playerX < 380
        playerX = playerX + 4
    end

    // Tir (simplifié - une balle à la fois)
    if isKeyPressed("space")
        bulletX = playerX
        bulletY = 280
        bulletActive = true
    end

    // Mise à jour balle
    if bulletActive
        bulletY = bulletY - 6
        if bulletY < 0
            bulletActive = false
        end
        drawRect(bulletX, bulletY, 3, 8, "#FFFFFF")
    end

    // Ennemis simples (positions fixes)
    for i = 1 to 5
        let enemyX = i * 70
        let enemyY = 50
        drawRect(enemyX, enemyY, 20, 20, "#FF0000")

        // Collision balle-ennemi (basique)
        if bulletActive
            if (bulletX > enemyX - 10) && (bulletX < enemyX + 30) && (bulletY < enemyY + 20) && (bulletY > enemyY - 10)
                score = score + 100
                bulletActive = false
                // L'ennemi "disparaît" temporairement
            end
        end
    end

    // Affichage
    drawRect(playerX - 10, 280, 20, 20, "#00FF00")  // Joueur
    drawText("Score: " + score, 10, 20, "#FFFFFF")   // Interface
end

Bonnes Pratiques

1. Structure du Code

Organisation Claire

// === CONSTANTES ET CONFIGURATION ===
let SCREEN_WIDTH = 400
let SCREEN_HEIGHT = 300
let PLAYER_SPEED = 4

// === VARIABLES DE JEU ===
let playerX = 200
let playerY = 150
let gameState = "playing"  // "menu", "playing", "gameover"

// === FONCTIONS PRINCIPALES ===
function start()
    initializeGame()
end

function update()
    if gameState == "menu"
        handleMenu()
    else if gameState == "playing"
        handleGameplay()
    else if gameState == "gameover"
        handleGameOver()
    end
end

// === FONCTIONS SPÉCIALISÉES ===
function initializeGame()
    // ...
end

Nommage Cohérent

// ✅ Bon nommage
let playerSpeed = 4
let enemyCount = 5
let isGameOver = false

function updatePlayer()
    // ...
end

function drawEnemies()
    // ...
end

// ❌ Mauvais nommage
let s = 4           // Pas clair
let x1 = 5          // Pas descriptif
let flag = false    // Trop vague

2. Performance

Optimisation des Rendus

function update()
    // ✅ Effacer UNE FOIS par frame
    clearScreen("#000033")

    // ✅ Grouper les dessins similaires
    drawBackground()
    drawAllEnemies()
    drawPlayer()
    drawUI()
end

// ❌ À éviter
function update()
    clearScreen("#000033")
    drawPlayer()
    clearScreen("#000033")  // ❌ Double effacement
    drawEnemy()
    clearScreen("#000033")  // ❌ Triple effacement
end

Calculs Optimisés

// ✅ Calculer une fois, utiliser plusieurs fois
let playerCenterX = playerX + 10
let playerCenterY = playerY + 10

// Utiliser les valeurs calculées
drawCircle(playerCenterX, playerCenterY, 15, "#00FF00")
checkCollisionWithEnemies(playerCenterX, playerCenterY)

// ❌ Calculs répétitifs
drawCircle(playerX + 10, playerY + 10, 15, "#00FF00")
checkCollisionWithEnemies(playerX + 10, playerY + 10)  // Recalcule

3. Lisibilité

Commentaires Utiles

// === GESTION DES COLLISIONS ===
function checkPlayerEnemyCollision()
    for i = 1 to enemyCount
        let enemyX = enemies[i].x
        let enemyY = enemies[i].y

        // Calcul de la distance euclidienne
        let dx = playerX - enemyX
        let dy = playerY - enemyY
        let distance = (dx * dx) + (dy * dy)

        // Collision si distance < rayon combiné au carré
        if distance < 400  // (10+10)² = 400
            handlePlayerHit()
        end
    end
end

Code Auto-Documenté

// ✅ Variables explicites
let COLLISION_RADIUS = 20
let PLAYER_LIVES = 3
let ENEMY_SPAWN_RATE = 60  // frames entre chaque spawn

if frameCount % ENEMY_SPAWN_RATE == 0
    spawnNewEnemy()
end

// ❌ Nombres magiques
if frameCount % 60 == 0  // Pourquoi 60 ?
    spawnNewEnemy()
end

4. Gestion d'État

États de Jeu Clairs

let gameState = "menu"  // "menu", "playing", "paused", "gameover"

function update()
    if gameState == "menu"
        handleMenuInput()
        drawMenu()
    else if gameState == "playing"
        updateGameLogic()
        drawGame()
    else if gameState == "paused"
        handlePauseInput()
        drawPausedGame()
    else if gameState == "gameover"
        handleGameOverInput()
        drawGameOver()
    end
end

5. Débogage

Messages de Debug

let DEBUG_MODE = true

function update()
    // Logique normale
    updatePlayer()

    // Informations de debug
    if DEBUG_MODE
        drawText("Player: (" + playerX + ", " + playerY + ")", 10, 280, "#YELLOW")
        drawText("FPS: 60", 300, 280, "#YELLOW")
        drawText("Enemies: " + enemyCount, 10, 260, "#YELLOW")
    end
end

🎯 Récapitulatif

Le langage Kod vous permet de créer facilement des jeux 2D avec :

✅ Syntaxe simple : if/end, function/end
✅ Typage automatique : Variables flexibles
✅ API graphique : Formes, texte, couleurs
✅ Gestion d'entrées : Clavier intégré
✅ Boucle de jeu : start() et update()

Étapes Suivantes

  1. 🎮 Explorez les Exemples Complets
  2. 🎯 Suivez le Guide de Création de Jeux
  3. 🔍 Consultez l'API de Référence

Bon coding avec Kod ! 🚀