CHAMP DE VISION AVEC OBSTACLES - AS3

Commentaire de pegase31 le 06/09/2011 17:02:23 administrateur CS

Alors en voyant la source, je me suis dit "chouette, enfin un truc sympa qui rend bien et qui en plus à l'avantage de fonctionner parfaitement" ... Mais ..

Il y a toujours un "mais" dans ce cas, car c'est effectivement de l'AS2 traduit ...
Mais j'avoue ne pas bien saisir le but de l'avoir passé en AS3 si tu ne profites pas de la puissance de cette version de langage.

Quand je vois ça : "MovieClip.prototype.policier = function ()", ça me fait dresser les poils sur les bras ...

Comment dire sans te froisser ?
"Ben oui, mais NON, en fait ..."

Pas de classes des fonctions simplement arrangées pour que ça tourne en AS3 .. quel est l'intérêt final ?

Peg'

Commentaire de t_naulet le 07/09/2011 10:51:25

Désolé, c'est une version CS5...

Commentaire de t_naulet le 09/09/2011 13:43:59

Le fichier enregistré CS4 est en ligne.
@Pegase31 : je ne suis vraiment pas un expert des classes AS3. Mais il va bien falloir que je m'y mette alors si j'ai un peu de temps, j'essaierai de transformer ce fichier... Est ce que tu sais si cela pourrait avoir des répercussions sur les performances du swf ?

Commentaire de tatactic le 12/09/2011 11:15:45

[quote]Pas de classes des fonctions simplement arrangées pour que ça tourne en AS3 .. quel est l'intérêt final ?

Peg'[/quote]
Si AS3 avait une classe main et vérifiait un peu plus les erreurs on n'aurait plus ce genre d'erreur non plus... Et moins de détracteurs pour flash en général.
Genre un exemple vite pondu et évidemment purement théorique quoiqu'il fonctionne:
package classes.main {
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;
import flash.utils.getQualifiedSuperclassName;
// ???
import flash.display.MovieClip;
// ? abberation in AS3 ?
// The main class must extends flash.displayMovieClip
// to be the main MovieClip container
// a Main class should be welcome. as here bellow
// this will provide a more intuitive main Method like in java.

public class Appli extends MovieClip{

public static var application:Appli;
protected static var debug:Boolean = true;
protected static var classToString:String;
protected var instanceToString:String;
protected static const TAB:String = " ";
protected static const ARROW:String = TAB + "->" + TAB;
protected static const DEBUG_MODE_ON_MSG:String = ARROW + "Application is running in debug mode.";
protected static const DEBUG_MODE_OFF_MSG:String = ARROW + "Application debug mode is turned off.";
protected static const AS3_REM:String = "AS3 main class must extends flash.display.MovieClip";
protected static const PERSO_ERROR_CODE:int = 123123123;
// -----------------------------------------
// public "Appli"
// -----------------------------------------
public function Appli():void {
/** CONSTRUCTOR */
forceMain();
}
// -----------------------------------------
// public static void "main"
// -----------------------------------------
public static function main(...args):void{
args = toArrayOfString(args);
// force to type args as Array of String
log ("@args = " + args);
// Output @args in debug mode ON

classToString = getDefinitionByName(getQualifiedClassName(Appli)).toString();
application = new Appli();
log(application.toString() + " " + "object successfuly created");
}
// -----------------------------------------
// private static void "toArrayOfString"
// Check type of main(String[] string);
// -----------------------------------------
private static function toArrayOfString(args:Array):Array{
var argsArray:Array = new Array();
for (var n:int = 0; n < args.length; n ++){
try{
//log(getDefinitionByName(getQualifiedClassName(args[n])).toString());
if((getDefinitionByName(getQualifiedClassName(args[n])) == "[class String]")){
argsArray[n] = args[n]
}else{
var msg:String = "argument " + n + " is not a String.\n Fatal Error";
throw new Error(msg,PERSO_ERROR_CODE);
}
}catch(e:Error){
if(e){
throw new Error(e.message,e.errorID);
}
}
}
return (argsArray as Array);
}
// -----------------------------------------
// public static void "log"
public static function log(string:String):void{
if(debug == true){
trace(string);
}
}
// -----------------------------------------
// protected static Boolean "forceMain"
protected static function forceMain():Boolean{
try{
if(classToString == null){
throw new Error("Appli constructor must be called via the main Method",PERSO_ERROR_CODE);
}
}catch(e:Error){
throw e;
}
log(classToString + " " + "constructor called");
classToString = null;
return true;
}
// -----------------------------------------
// Boolean debugVersion setter and getter
// permit log action if set to true
// ommit them if set to false
public static function set debugVersion(bool:Boolean):void{
debug = bool;
}
public static function get debugVersion():Boolean{
return debug;
}
// -----------------------------------------
// String debug_status getter
// tells if the application is running in debug mode
// Output :
// -> Application is running in debug mode. (DEBUG_MODE_ON_MSG)
// or -> Application debug mode is turned off. (DEBUG_MODE_OFF_MSG)
//
public static function get debug_status():String{
var outputString:String = "";
switch (debugVersion){
case true:
outputString = DEBUG_MODE_ON_MSG;
return outputString;
break;
case false:
outputString = DEBUG_MODE_OFF_MSG;
return outputString;
break;
default:
var error:Error = new Error("Debug mode is not set.\nFatal ERROR.",PERSO_ERROR_CODE);
throw error;
break;
return error.message;
}
}
public override function toString():String{
// mark this method as override if this class extends MovieClip !
// unmark this method as override if this class DO NOT extends MovieClip !
return "[" + "object" + " " + "Appli"+ "]";
}
public function get objectToString():String{
var outputString:String = application.toString() + " extends ::" + getDefinitionByName(getQualifiedSuperclassName(Appli)) + " " + AS3_REM;
return outputString;
}
public static function get objectToString():String{
var outputString:String = getDefinitionByName(getQualifiedClassName(Appli)).toString() + " extends ::" + getDefinitionByName(getQualifiedSuperclassName(Appli)) + " " + AS3_REM;
return outputString;
}


}

}

Puis dans le FLA :
1 / Impossible de le lier via le panneau properties du fla.
2 / appel de main :
import classes.main.Appli;

/*
/* if Appli.debugVersion == true
/* permit log outputs
/* if Appli.debugVersion == false
/* ommit log outputs
*/
Appli.main("test","1");
trace(Appli.application);
/*
/* call the main method of void Appli
*/
trace(Appli.debug_status);
/*
/* trace the debug status by default;
/* output :
/* -> Application is running in debug mode.
*/
Appli.debugVersion = false;
/*
/* change the debug status by default;
*/
trace(Appli.debug_status);
/*
/* trace the new debug status;
/* output :
/* -> Application debug mode is turned off.
*/

trace(Appli.application.objectToString);
/*
/* output :
/* [object Appli]
*/
trace(Appli.objectToString);
/*
/* output :
/* [class Appli]
*/

/**
/* if "classes.main.Appli" extends MovieClip and
/* "classes.main.Appli" is specified in the
/* Class field of the properties pannel,
/* this will throw an Error.
/* Error: Appli constructor must be called via the main Method
/* at classes.main::Appli()
/*
/* (THIS FORCE THE CALL TO main method of the class)
/* force to call Appli like this :
/* - - - - - - - - - - - - - - - -
/* import classes.main.Appli;
/* Appli.main(String[] ...args);
*/
J'espère qu'Adobe fera un peu le ménage dans les codeurs en sortant AS4...

Commentaire de tatactic le 12/09/2011 11:59:08

Oui, c'est théorique...
C'est juste que ça ne me semble pas évident de
- ne pas devoir construire le Stage
- d'avoir la classe principale qui doit étendre MovieClip d'office.
Par rapport à Java ça fait un peu drôle... C'est comme si la classe principale héritait d'office de Frame ou JFrame alors que bon...
Les éléments des Arrays pas typés en AS3 (équivalent à Vector)... D'où la vérification du typage des éléments fournis quand on fait un méthode(...args) où ...args n'est pas typé etc etc.
Bref juste une idée pour que AS3 soit plus strict lors de la prochaine version afin d'éviter à certains de coder parfois sans trop se soucier de trucs importants genre un throw qui ne doit pas spécialement avoir un catch...
Ce sont des petites choses qui font que certains ne prennent pas AS3 au sérieux (à tort selon moi) et qui donnent le loisir à certains de coder un peu à l'aveuglette.

Commentaire de aerolyte le 12/09/2011 12:15:00

Personnellement, je pense que c'est un avantage d'avoir la liberté ou non de typer.
Parfois il est meme indispensable de transtyper.
Le tout est d'avoir conscience de ce que cela implique ou non de le faire.

Quant au sérieux d'un language, ca me fait doucement rire, c'est plutot un qualificatif que l'on utilise pour un humain. Sans doute est-ce une marque de ce meme manque chez ces auteurs.

Quant l'obligation d'étendre (directement ou non) la class main avec un displyObject, je la comprend comme justement comme son affectation sur la scene permettant ainsi d'obtenir le "Stage".

Commentaire de tatactic le 12/09/2011 14:24:40

Le bout de code (très maso je l'avoue!) on peut l'oublier en effet, c'et juste une façon d'illustrer une idée.
C'est long et inutile mais AS4 pourrait être plus strict afin d'éviter certaines choses.
Ou alors dans un environement de travail tomber enfin d'accord sur certaines habitudes à respecter pour ne pas avoir trop de mauvaises surprises lors de modifs un peu brutales quand on n'est pas là... :)
Il y a de plus en plus de graphistes qui se mettent à toucher à du code et ce n'est pas souvent très réutilisable, voir par moments assez cata ;)
Donc je sautais juste sur l'occasion pour dire qu'en effet je ne critiquais pas la source mais que j'étais d'accord avec le principe de "juste une traduction pour AS3", chose qui peut être assez gênante en prod.
Bon, pardon donc et autant pour moi :)