Erreur 1009 en sortie

Bonjours lorsque j'ai compiler ma machine j'ai eu cette erreur en sortie:

TypeError: Error #1009: Il est impossible d'accéder à la propriété ou à la méthode d'une référence d'objet nul.

at com.jac.fsm::StateViewController/registerSubViews()
at com.jac.fsm::StateViewController()
at SpaceRocks()


Merci d'avance

Bonjour,

Tu essaies donc d'accéder à une propriété ou référence d'un objet nul.
Ok .. et donc ?

Peg'

J'aimerai bien savoir comment corriger cette faute. d'habitude c'est quoi qui donne se type d'erreur

Ben le fait d'essayer d'accéder à un objet non instancié (mais déclaré) ou une propriété nulle ...
C'est justement le message d'erreur.

Vérifie que tes objets sont bien tous créés et que tes méthodes/propriétés sont bien remplies après les avoir déclarées.

Peg'

sincerement je ne vois pas vraiment je vais te passe les bout de code, selon les message d'erreurs

package {
import flash.display.*;
import flash.events.*;
import flash.text.*;
import flash.utils.getTimer;
import flash.utils.Timer;
import flash.geom.Point;

import flash.display.MovieClip;
import flash.display.StageDisplayState;
import com.jac.fsm.GroupController;
import com.jac.fsm.StateMachine;
import com.jac.fsm.StateViewController;
import com.jac.fsm.StateController;
import com.jac.fsm.StateView;
import flash.events.MouseEvent;

public class SpaceRocks extends MovieClip
{
static const shipRotationSpeed:Number = .1;
static const rockSpeedStart:Number = .03;
static const rockSpeedIncrease:Number = .02;
static const missileSpeed:Number = .2;
static const thrustPower:Number = .15;
static const shipRadius:Number = 20;
static const startingShips:uint = 3;

// variable concernant l'appel des StateMachine et Controller

private var _StateContainer:MovieClip;

private var _ATDENVIEW:StateView;
private var _ARIVENVIEW:StateView;
private var _MORTVIEW:StateView;
private var _sm:StateMachine;
private var _ssm:StateMachine;
private var _ATDENVC:StateViewController;
private var _ARIVENVC:StateViewController;
private var _MORTVC:StateViewController;
private var _phase1CSM:GroupController;
private var _phase2CSM:GroupController;

// objet du jeux
var ship:Ship;
var rocks:Array;
var missiles:Array;

// timer (durée) animation
var lastTime:uint;

// touche clavier
var rightArrow:Boolean = false;
var leftArrow:Boolean = false;
var upArrow:Boolean = false;

// vitesse vaisseaux
var shipMoveX:Number;
var shipMoveY:Number;

// timers
var delayTimer:Timer;
var shieldTimer:Timer;

// mode de jeux
var gameMode:String;
var shieldOn:Boolean;

// vaisseaux et bouclier
var shipsLeft:uint;
var shieldsLeft:uint;
var shipIcons:Array;
var shiptouch: Boolean;

var shieldIcons:Array;
var scoreDisplay:TextField;

// score and level
var gameScore:Number;
var gameLevel:uint;

// sprites
var gameObjects:Sprite;
var scoreObjects:Sprite;

public function SpaceRocks()
{

_ATDENVIEW = new ATDEN_STATE();
_ARIVENVIEW = new ARIVEN_STATE();
_MORTVIEW = new MORT_STATE();

trace("Creation");

_sm = new StateMachine(true, true);
_ssm = new StateMachine(true, true);

_ATDENVC = new StateViewController([_ATDENVC], _StateContainer);
_ARIVENVC = new StateViewController([_ARIVENVIEW], _StateContainer);
_MORTVC = new StateViewController([_ARIVENVIEW], _StateContainer);

_phase1CSM = new GroupController([_ATDENVC,_ARIVENVC]);
_phase2CSM = new GroupController([_MORTVC]);

_sm.changeState(_phase1CSM);
_ssm.changeState(_MORTVC);

stage.addEventListener(KeyboardEvent. KEY_DOWN, handleButtonkeyDownFunction, false, 0, true);
stage.addEventListener(KeyboardEvent. KEY_UP, handleButtonkeyUpFunction, false, 0, true);
startButton.addEventListener(MouseEvent.CLICK, handleClickStart, false, 0, true);
playAgainButton.addEventListener(MouseEvent.CLICK, handleClickPlayAgain, false, 0, true);


}


private function handleButtonkeyDownFunction(event: KeyboardEvent):void
{
if (event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39)
{
trace("---BUTTON CLICK---");
if (_sm.currentState == _phase1CSM)
{
_sm.changeState(_phase2CSM);
}
else
{
_sm.changeState(_phase1CSM);
}
}
}

private function handleButtonkeyUpFunction(event: KeyboardEvent):void
{
if (event.keyCode == 37 || event.keyCode == 38 || event.keyCode == 39)
{
trace("---BUTTON CLICK---");
if (_sm.currentState == _phase1CSM)
{
_sm.changeState(_phase2CSM);
}
else
{
_sm.changeState(_phase1CSM);
}
}
}

private function handleClickStart(e:MouseEvent):void
{
if (_sm.currentState == _phase1CSM)
{
_sm.changeState(_phase2CSM);
}
else
{
_sm.changeState(_phase1CSM);
}

}

private function handleClickPlayAgain(e:MouseEvent):void
{
if (_sm.currentState == _phase1CSM)
{
_sm.changeState(_phase2CSM);
}
else
{
_sm.changeState(_phase1CSM);
}

}
/////////////////////////////////////////////////////////////////////////////////////////

// début du jeux
public function startSpaceRocks() {
// set up sprites
gameObjects = new Sprite();
addChild(gameObjects);
scoreObjects = new Sprite();
addChild(scoreObjects);

// initialisation score objects
gameLevel = 1;
shipsLeft = startingShips;
gameScore = 0;
createShipIcons();
createScoreDisplay();

// set up listeners
addEventListener(Event.ENTER_FRAME,moveGameObjects);
stage.addEventListener(KeyboardEvent.KEY_DOWN,keyDownFunction);
stage.addEventListener(KeyboardEvent.KEY_UP,keyUpFunction);


// début
gameMode = "delay";
shieldOn = false;
missiles = new Array();
nextRockWave(null);
newShip(null);
}


// SCORE OBJECTS

// compte nombre vaisseau enlevé
public function createShipIcons() {
shipIcons = new Array();
for(var i:uint=0;i<shipsLeft;i++) {
var newShip:ShipIcon = new ShipIcon();
newShip.x = 20+i*15;
newShip.y = 375;
scoreObjects.addChild(newShip);
shipIcons.push(newShip);
}
}

// compte nombre bouclier enlevé
public function createShieldIcons() {
shieldIcons = new Array();
for(var i:uint=0;i<shieldsLeft;i++) {
var newShield:ShieldIcon = new ShieldIcon();
newShield.x = 530-i*15;
newShield.y = 375;
scoreObjects.addChild(newShield);
shieldIcons.push(newShield);
}
}

// Afficher le score en haut à droite
public function createScoreDisplay() {
scoreDisplay = new TextField();
scoreDisplay.x = 500;
scoreDisplay.y = 10;
scoreDisplay.width = 40;
scoreDisplay.selectable = false;
var scoreDisplayFormat = new TextFormat();
scoreDisplayFormat.color = 0xFFFFFF;
scoreDisplayFormat.font = "Arial";
scoreDisplayFormat.align = "right";
scoreDisplay.defaultTextFormat = scoreDisplayFormat;
scoreObjects.addChild(scoreDisplay);
updateScore();
}

// montrer le nouveau score
public function updateScore() {
scoreDisplay.text = String(gameScore);
}

// enlevé les icônes vaisseau
public function removeShipIcon() {
scoreObjects.removeChild(shipIcons.pop());
}

// enlevé les icônes armure
public function removeShieldIcon() {
scoreObjects.removeChild(shieldIcons.pop());
}

// enlevé le reste des icônes vaisseau
public function removeAllShipIcons() {
while (shipIcons.length > 0) {
removeShipIcon();
}
}

// enlevé le reste des icône bouclier
public function removeAllShieldIcons() {
while (shieldIcons.length > 0) {
removeShieldIcon();
}
}


// VAISSEAUX CREATION + DEPLACEMENT

// création nouveau vaisseau
public function newShip(event:TimerEvent) {
// if ship exists, remove it
if (ship != null) {
gameObjects.removeChild(ship);
ship = null;
}

// pas plus de vaisseau
if (shipsLeft < 1) {
endGame();
return;
}

// créer, position, and add new ship
ship = new Ship();
ship.gotoAndStop(1);
ship.x = 275;
ship.y = 200;
ship.rotation = -90;
ship.shield.visible = false;
gameObjects.addChild(ship);

// ajouter vaisseau proprieté
shipMoveX = 0.0;
shipMoveY = 0.0;
gameMode = "play";

// ajouter bouclier proprieté
shieldsLeft = 3;
createShieldIcons();

// début jeux avec toutes vies + un bouclier gratuit
if (shipsLeft != startingShips) {
startShield(true);
}
}

// enregister bouton clavier pressé
public function keyDownFunction(event:KeyboardEvent) {
if (event.keyCode == 37) {
leftArrow = true;
} else if (event.keyCode == 39) {
rightArrow = true;
} else if (event.keyCode == 38) {
upArrow = true;
// show thruster
if (gameMode == "play") ship.gotoAndStop(2);
} else if (event.keyCode == 32) { // space
newMissile();
} else if (event.keyCode == 90) { // z
startShield(false);
}
}

// enregister bouton clavier depressé
public function keyUpFunction(event:KeyboardEvent) {
if (event.keyCode == 37) {
leftArrow = false;
} else if (event.keyCode == 39) {
rightArrow = false;
} else if (event.keyCode == 38) {
upArrow = false;
// remove thruster
if (gameMode == "play") ship.gotoAndStop(1);
}
}

// animer vaisseau
public function moveShip(timeDiff:uint) {

// rotation + poussé(acceleration)
if (leftArrow) {
ship.rotation -= shipRotationSpeed*timeDiff;
} else if (rightArrow) {
ship.rotation += shipRotationSpeed*timeDiff;
} else if (upArrow) {
shipMoveX += Math.cos(Math.PI*ship.rotation/180)*thrustPower;
shipMoveY += Math.sin(Math.PI*ship.rotation/180)*thrustPower;
}

// bouger
ship.x += shipMoveX;
ship.y += shipMoveY;

// enrouler autour de l'écran
if ((shipMoveX > 0) && (ship.x > 570)) {
ship.x -= 590;
}
if ((shipMoveX < 0) && (ship.x < -20)) {
ship.x += 590;
}
if ((shipMoveY > 0) && (ship.y > 420)) {
ship.y -= 440;
}
if ((shipMoveY < 0) && (ship.y < -20)) {
ship.y += 440;
}
}

// supprimer vaisseau
public function shipHit() {
gameMode = "delay";
ship.gotoAndPlay("explode");
removeAllShieldIcons();
delayTimer = new Timer(2000,1);
delayTimer.addEventListener(TimerEvent.TIMER_COMPLETE,newShip);
delayTimer.start();
removeShipIcon();
shipsLeft--;
}

// bouclier tourne autour du vaisseau pendant 3 seconde
public function startShield(freeShield:Boolean) {
if (shieldsLeft < 1) return; // no shields left
if (shieldOn) return; // shield already on

// regler le minutage pour arrêter le bouclier
ship.shield.visible = true;
shieldTimer = new Timer(3000,1);
shieldTimer.addEventListener(TimerEvent.TIMER_COMPLETE,endShield);
shieldTimer.start();

// mise à jour reste bouclier
if (!freeShield) {
removeShieldIcon();
shieldsLeft--;
}
shieldOn = true;
}

// désactiver bouclier
public function endShield(event:TimerEvent) {
ship.shield.visible = false;
shieldOn = false;
}

// ROCHE

// création différent rochés avec taille
public function newRock(x,y:int, rockType:String) {

// création d'une classe approprié
var newRock:MovieClip;
var rockRadius:Number;
if (rockType == "Big") {
newRock = new Rock_Big();
rockRadius = 35;
} else if (rockType == "Medium") {
newRock = new Rock_Medium();
rockRadius = 20;
} else if (rockType == "Small") {
newRock = new Rock_Small();
rockRadius = 10;
}

// Here is an alternate way to do the above, without a case statement
// Need to import flash.utils.getDefinitionByName to use
/*
var rockClass:Object = getDefinitionByName("Rock_"+rockType);
var newRock:MovieClip = new rockClass();
*/

// choisir une vu aléatoire
newRock.gotoAndStop(Math.ceil(Math.random()*3));

// set start position
newRock.x = x;
newRock.y = y;

// mouvement rocher et rotation aléatoire
var dx:Number = Math.random()*2.0-1.0;
var dy:Number = Math.random()*2.0-1.0;
var dr:Number = Math.random();

// add to stage and to rocks list
gameObjects.addChild(newRock);
rocks.push({rock:newRock, dx:dx, dy:dy, dr:dr, rockType:rockType, rockRadius: rockRadius});
}

// création de 4 roché initial
public function nextRockWave(event:TimerEvent) {
rocks = new Array();
newRock(100,100,"Big");
newRock(100,300,"Big");
newRock(450,100,"Big");
newRock(450,300,"Big");
gameMode = "play";
}

// animer les rochés
public function moveRocks(timeDiff:uint) {
for(var i:int=rocks.length-1;i>=0;i--) {

// bouger les rochés
var rockSpeed:Number = rockSpeedStart + rockSpeedIncrease*gameLevel;
rocks[i].rock.x += rocks[i].dx*timeDiff*rockSpeed;
rocks[i].rock.y += rocks[i].dy*timeDiff*rockSpeed;

// rotation des rochés
rocks[i].rock.rotation += rocks[i].dr*timeDiff*rockSpeed;

// disimuler les rochés
if ((rocks[i].dx > 0) && (rocks[i].rock.x > 570)) {
rocks[i].rock.x -= 590;
}
if ((rocks[i].dx < 0) && (rocks[i].rock.x < -20)) {
rocks[i].rock.x += 590;
}
if ((rocks[i].dy > 0) && (rocks[i].rock.y > 420)) {
rocks[i].rock.y -= 440;
}
if ((rocks[i].dy < 0) && (rocks[i].rock.y < -20)) {
rocks[i].rock.y += 440;
}
}
}

public function rockHit(rockNum:uint) {
// création de 2 petit rochés
if (rocks[rockNum].rockType == "Big") {
newRock(rocks[rockNum].rock.x,rocks[rockNum].rock.y,"Medium");
newRock(rocks[rockNum].rock.x,rocks[rockNum].rock.y,"Medium");
} else if (rocks[rockNum].rockType == "Medium") {
newRock(rocks[rockNum].rock.x,rocks[rockNum].rock.y,"Small");
newRock(rocks[rockNum].rock.x,rocks[rockNum].rock.y,"Small");
}
// supprimer roché original
gameObjects.removeChild(rocks[rockNum].rock);
rocks.splice(rockNum,1);
}


// MISSILES

// creation d'un nouveau missile
public function newMissile() {
// create
var newMissile:Missile = new Missile();

// indiquer direction missile
newMissile.dx = Math.cos(Math.PI*ship.rotation/180);
newMissile.dy = Math.sin(Math.PI*ship.rotation/180);

// placement
newMissile.x = ship.x + newMissile.dx*shipRadius;
newMissile.y = ship.y + newMissile.dy*shipRadius;

// ajouter à la scène + tableau
gameObjects.addChild(newMissile);
missiles.push(newMissile);
}

// animer missiles
public function moveMissiles(timeDiff:uint) {
for(var i:int=missiles.length-1;i>=0;i--) {
// bouger
missiles[i].x += missiles[i].dx*missileSpeed*timeDiff;
missiles[i].y += missiles[i].dy*missileSpeed*timeDiff;
// moved off screen
if ((missiles[i].x < 0) || (missiles[i].x > 550) || (missiles[i].y < 0) || (missiles[i].y > 400)) {
gameObjects.removeChild(missiles[i]);
delete missiles[i];
missiles.splice(i,1);
}
}
}

// supprimer missile
public function missileHit(missileNum:uint) {
gameObjects.removeChild(missiles[missileNum]);
missiles.splice(missileNum,1);
}

// interaction jeux et contrôle

public function moveGameObjects(event:Event) {
// get timer difference and animate
var timePassed:uint = getTimer() - lastTime;
lastTime += timePassed;
moveRocks(timePassed);
if (gameMode != "delay") {
moveShip(timePassed);
}
moveMissiles(timePassed);
checkCollisions();
}

// Recherche des missiles en collision avec des roches
public function checkCollisions() {
shiptouch = false;
rockloop: for(var j:int=rocks.length-1;j>=0;j--) {
// boucles missiles
missileloop: for(var i:int=missiles.length-1;i>=0;i--) {
// detection colision
if (Point.distance(new Point(rocks[j].rock.x,rocks[j].rock.y),
new Point(missiles[i].x,missiles[i].y))
< rocks[j].rockRadius) {
shiptouch = true;
//supprimer roché et missile
rockHit(j);
missileHit(i);

// additioner au score
gameScore += 10;
updateScore();

// sortir de cette boucle et continuer sur le suivant
continue rockloop;
}
}

// voir si roché touche le vaisseau
if (gameMode == "play") {
if (shieldOn == false) { // seulement si bouclier est désactiver
if (Point.distance(new Point(rocks[j].rock.x,rocks[j].rock.y),
new Point(ship.x,ship.y))
< rocks[j].rockRadius+shipRadius) {

// supprimer roché + vaisseau
shipHit();
rockHit(j);
}
}
}
}

// plus de roché,changement de mode de jeux et + de déclenchement (en gros passer au niveau suivant)
if ((rocks.length == 0) && (gameMode == "play")) {
gameMode = "betweenlevels";
gameLevel++; // ajouter un niveau
delayTimer = new Timer(2000,1);
delayTimer.addEventListener(TimerEvent.TIMER_COMPLETE,nextRockWave);
delayTimer.start();
}
}

public function endGame() {
// enleve tous les objets et les listeners
removeChild(gameObjects);
removeChild(scoreObjects);
gameObjects = null;
scoreObjects = null;
removeEventListener(Event.ENTER_FRAME,moveGameObjects);
stage.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownFunction);
stage.removeEventListener(KeyboardEvent.KEY_UP,keyUpFunction);

gotoAndStop("gameover");
}

}
}

package com.jac.fsm
{
import com.jac.fsm.interfaces.IState;
import flash.display.MovieClip;
import flash.events.IEventDispatcher;
import com.jac.fsm.stateEvents.StateEvent;

/**
* This is the controller for each display state of type <code>StateView</code>. This must contain a <code>StateView</code> object that it controls.
*/
public class StateViewController extends StateController implements IState
{//StateViewController class

private var _container:MovieClip;

private var _viewExitCount:int = 0;
private var _viewEnterCount:int = 0;

/**
* This is the controller for each display state of type <code>StateView</code>. This must contain a <code>StateView</code> object that it controls.
*
* @param stateViewList an array of views to be controlled by this controller.
* @param container a MovieClip that will be used to contain and be the parent of the items in the <code>stateViewList</code> parameter.
*/
public function StateViewController(stateViewList:Array, container:MovieClip)
{//StateViewController
super();
//trace("Setting container to: " + container + " " + container.name);
_container = container;
_subObjList = new Array();
registerSubViews(stateViewList);
}//StateViewController

/**
* This registers any views in the view list as well as recursively searching through those views for other views contained within.
* If it finds more views contained, it will register those as well.
*
* @param viewList
*/
private function registerSubViews(viewList:Array):void
{//registerSubViews
for (var i:int = 0; i < viewList.length; i++)
{//find views
if (viewList[i].subViews.length > 0)
{//find more
registerSubViews(viewList[i].subViews);
}//find more

//Register view
registerSubObject(viewList[i]);
}//find views
}//registerSubViews

///////////////////// MANAGEMENT FUNCTIONS /////////////////////
/**
* @inheritDoc
*/
override public function registerSubObject(newStateView:IState):void
{//registerStateView
if (!(newStateView is StateView))
{//error
throw Error("StateViewController:unregisterSubObject: expected StateView, got " + newStateView + ".");
}//error
else
{//good
_subObjList.push(newStateView);
}//good

}//registerStateView

/**
* @inheritDoc
*/
override public function unregisterSubObject(oldStateView:IState):void
{//unregisterStateView
if (!(oldStateView is StateView))
{//error
throw Error("StateViewController:unregisterSubObject: expected StateView, got " + oldStateView + ".");
}//error
else
{//good
var removedAny:Boolean = false;
for (var i:int = 0; i < _subObjList.length; i++)
{//find
if (_subObjList[i] == oldStateView)
{//remove
removedAny = true;
_subObjList.splice(i, 1);
break;
}//remove
}//find

if (!removedAny)
{//warning
trace("--FSM--StateViewController--: Did not find " + oldStateView + " in registered stateViewList list");
}//warning
}//good

}//unregisterStateView

///////////////////// CONTROLLING FUNCTIONS ////////////////////
/**
* When called, this will add all of the views and subviews to the display list. Once that has completed, it
* calls <code>enter()</code> on each of those added views.
*/
override public function enter():void
{//enter
addToDisplayList();
enterSubObjects();
}//enter

/**
* @inheritDoc
*/
override protected function handleExitComplete(e:StateEvent):void
{//handleExitComplete
//trace("StateViewController handleExitComplete: " + e.target);
exitComplete(e);
}//handleExitComplete

/**
* Adds all of the views and subviews to the <code>_container</code> clip, essentially adding them to the display list.
*
* @see _container
*/
public function addToDisplayList():void
{//addToDisplayList
for (var i:int = 0; i < _subObjList.length; i++)
{//add them
if (!_subObjList[i].instanciatedFromIDE)
{//add
//trace("-- Adding " + _subObjList[i] + " " + _subObjList[i].name + " to " + _container + " " + _container.name);
_container.addChild(_subObjList[i]);
}//add
else
{//already added
trace("-- Already Added: " + _subObjList[i] + " " + _subObjList[i].name + " to " + _subObjList[i].parent + " / " + _subObjList[i].parent.name);
}//already added
}//add them
}//addToDisplayList

/**
* Removes all of the children of <code>_container</code> from the display list.
*/
public function removeFromDisplayList():void
{//removeFromDisplayList
for (var i:int = 0; i < _subObjList.length; i++)
{//add them
//trace("-- Removing " + _subObjList[i] + " " + _subObjList[i].name + " from " + _subObjList[i].parent + " " + _subObjList[i].parent.name);

//Don't remove if put there in the ide
if (!_subObjList[i].instanciatedFromIDE)
{//remove
_subObjList[i].parent.removeChild(_subObjList[i]);
}//remove

}//add them
}//removeFromDisplayList

/**
* @inheritDoc
*/
override protected function exitComplete(e:StateEvent):void
{//exitComplete
e.target.removeEventListener(StateEvent.EXIT_COMPLETE, handleExitComplete);

//inc count
_exitCount++;

//trace("SVC:Exiting: " + e.target + " / " + _exitCount + " / " + _subObjList.length);

if (_exitCount == _subObjList.length)
{//done !
//trace(this + " Exit Completed, notifying...");
_subObjList.reverse();
removeFromDisplayList();
notifyExitComplete(new StateEvent(StateEvent.EXIT_COMPLETE, this, false, false));
}//done!
}//exitComplete


////////////////////////////// EVENT HANDLERS ////////////////////////////

///////////////////////////// GETTERS/ SETTERS //////////////////////////////////

/**
* returns a list of the sub views.
*/
public function get stateViews():Array
{//get stateView
return _subObjList;
}//get stateView

/**
* Returns or sets the container object of all of the sub views.
*/
public function get container():MovieClip
{
return _container;
}
/**
* @private
*/
public function set container(value:MovieClip):void
{
_container = value;
}

////////////////////////// OVERRIDES /////////////////////
/**
* @inheritDoc
*/
override public function toString():String
{//toString
return ("StateViewController: " + GetStateName(this));
}//toString
}//StateViewController class

}

Apparemment, le code n'est pas de toi (ou alors tu commentes en anglais)

Ensuite si tu lis le message d'erreur, tu vois qu'il t'indique l'endroit de l'erreur :



Pour savoir d'où vient le soucis il faut prendre à l'inverse : ton erreur se situe dans com.jac.fsm::StateViewController/registerSubViews() et est déclenchée à la base par la fonction SpaceRocks().

Sachant que la fonciton "registerSubViews()" est récursive, si un élément de ton tableau en paramètre est nul, ça affichera ce message d'erreur.

Peg'

oui c'est vrai c'est pas mon code je dois réaliser une machine a état fini en faisant tourner un jeux, mais comme base mon maître de stage ma deja donner un base qu il a trouver sur internet.

Ensuite comment je peux savoir , premièrement de quel tableau il s'agit et comment dois.je faire pour le remplir

Il faut pour celo suivre ton code .. c'est justement pour ça qu'il t'a donné un code "tout fait".
Comment ais-je su que le problème viendrait du tableau ?

Encore une fois le message d'erreur te donne la marche à suivre.

Peg'

oui mais je suis sensé le réadapter par rapport a mon jeux car avant la machine de base fonctionner, lorsque tu appuie sur un boutton la forme et la couleur du rectangle changeais

si je j ai bien compris le problème viendrait du tableau ???
et bien je vais faire quelque recherche alors