¿Cuánto debería unir estas funciones?

[Tachikomaia]

He puesto primero un pseudocódigo simple y luego el código original. Más adelante quizá ponga un pseudocódigo normal. Es cosa de uds qué leer, pero en cualquier caso supongo que conviene leer desde la dependencia más alta a la más baja, lo cual por momentos es "leer desde abajo hacia arriba".
Dependencia 0 significa que las funciones siguientes no tienen función alguna dentro de sí.
Dependencia 1 significa que incluye alguna función de dependencia 0.

Si tienen alguna duda pregunten y responderé si puedo.

De momento voy a hacer dows (do whiles) para definir ciertas cosas y luego intentaré unir las funciones Remove, que parecen las más simples, pero eso debo ver si conviene o no unirlas.

Gracias por la ayuda.

Pseudocódigo simple:

Código:

// Si la línea inicia con // entonces es un comentario.
// ////////////////////////////////////////
// ////   Readd líneas y sus botones   ////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
Funcion Reagregar_Lineas_tipo_Situación_parte:
	// Dice Situación pero en realidad esta función se usa en más tipos de líneas.
	Aumenta un contador y se define una variable para evitar repetir ciertas sumas.
Funcion Reagregar_Lineas_tipo_Situación_parte2:
	Se indica la posición "y" de una línea y de un objeto que contiene botones. También, en ese objeto, se crea una variable.
// ////////////////////////////////////////
// ///////////   Dependencia 1   //////////
// ////////////////////////////////////////
Funcion Reagregar_Lineas_tipo_Situación:
	// F2 = Se usa en el Frame 2.
	Se inicia o resetea un contador.
	Se repite:
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte.
		Se agrega una línea de tipo Situación.
		Se crean variables tipo Situación en la línea tipo Situación.
		Se agrega un objeto que contiene botones tipo Situación.
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte2.
	mientras el contador sea menor a la cantidad de elementos de la situación.
Funcion Reagregar_Lineas_tipo_Condición1:
	// F4.
	Se inicia o resetea un contador.
	Se repite:
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte.
		Se agrega una línea de tipo Condición1.
		Se crean variables tipo Condición1 en la línea tipo Condición1.
		Se agrega un objeto que contiene botones tipo Condición1.
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte2.
	mientras el contador sea menor a la cantidad de condiciones.
Funcion Reagregar_Lineas_tipo_Condición2:
	// F6.
	Se inicia o resetea un contador.
	Se repite:
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte.
		Se agrega una línea de tipo Condición2.
		Se crean variables tipo Condición2 en la línea tipo Condición2.
		Se agrega un objeto que contiene botones tipo Condición2.
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte2.
	mientras el contador sea menor a la cantidad de grupos.
Funcion Reagregar_Lineas_tipo_Cambios:
	// F8.
	Se inicia o resetea un contador.
	Se repite:
		Se aplica la función Reagregar_Lineas_tipo_Situación_parte.
		Se agrega una línea de tipo Cambios.
		Se crean variables tipo Cambios en la línea tipo Cambios.
		Se indica la posición x de la línea tipo Cambios.
		Se agrega un objeto que contiene botones tipo Cambios.
		Se crea una variable en dicho objeto.
		Se indica la posición x de dicho objeto.
	mientras el contador sea menor a la cantidad de cambios.
	// Esta función es un poco más diferente a las otras porque la línea en vez de ser una fila es una columna, entonces en vez de indicarse la posición y se indica la x y el cálculo es diferente además. Por eso no se usa la función "parte2".
// ////////////////////////////////////////
// /////   Add líneas y sus botones   /////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
Funcion Agregar_Lineas_tipo_Situación:
	// Usada en el botón + del F2.
	Aumenta la cantidad de elementos de la situación.
	Se agrega una línea de tipo Situación.
	Se crean variables tipo Situación en la línea tipo Situación.
	Se indica la posición y de la línea.
	Se agrega un objeto que contiene botones tipo Situación.
	Se crea una variable en dicho objeto.
	Se indica la posición y de dicho objeto.
	Se crean variables tipo Situación (en la raíz).
Funcion Agregar_Lineas_tipo_Condición1:
	// Usada en bot + en F4.
	Aumenta la cantidad de condiciones.
	Se agrega una línea de tipo Condición1.
	Se crean variables tipo Condición1 en la línea tipo Condición1.
	Se indica la posición y de la línea.
	Se agrega un objeto que contiene botones tipo Condición1.
	Se crea una variable en dicho objeto.
	Se indica la posición y de dicho objeto.
	Se crean variables tipo Condición1 (en la raíz).	
Funcion Agregar_Lineas_tipo_Condición2:
	// Bot + en F6.
	Aumenta la cantidad de grupos.
	Se agrega una línea de tipo Condición2.
	Se crean variables tipo Condición2 en la línea tipo Condición2.
	Se indica la posición y de la línea.
	Se agrega un objeto que contiene botones tipo Condición2.
	Se crea una variable en dicho objeto.
	Se indica la posición y de dicho objeto.
	Se crean variables tipo Condición2 (en la raíz).
// ////////////////////////////////////////
// ///   Remove líneas y sus botones   ////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
Funcion Remover_Linea_tipo_Situación:
	// Bot - en F2.
	Si la cantidad de elementos de situación es mayor que 1
		Quitar la última línea tipo Situación agregada.
		Quitar el último contenedor de botones tipo Situación agregado.
		La cantidad de elementos de situación disminuye 1.
Funcion Remover_Linea_tipo_Condición1:
	// Bot - en F4.
	Si la cantidad de condiciones es mayor que 1
		Quitar la última línea tipo Condición1 agregada.
		Quitar el último contenedor de botones tipo Condición1 agregado.
		La cantidad de condiciones disminuye 1.
Funcion Remover_Linea_tipo_Condición2:
	// Bot - en F6.
	Si la cantidad de grupos es mayor que 1
		Quitar la última línea tipo Condición2 agregada.
		Quitar el último contenedor de botones tipo Condición2 agregado.
		La cantidad de grupos disminuye 1.

[Tachikomaia]

Original:

Código:

// ////////////////////////////////////////
// ////   Readd líneas y sus botones   ////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
function ReaddSitLinep () {
	// p es parte; también usada por Func ReaddCond1Line
	// ReaddCond2Lines, ReaddCamLine
	A = A+1;
	B = "Lines.Line"+A;
}
function ReaddSitLinep2 () {
	// Func ReaddCond1Line, ReaddCond2Lines, ReaddCamLine
	C = 23.4*(A-1);
	setProperty (eval(B), _y, C);
	set ("LinesBots.Bot"+A+".A", A);
	// En cada línea de bots, var que indica qué nro de linea es.
	setProperty ("LinesBots.Bot"+A, _y, C);
}
// ////////////////////////////////////////
// ///////////   Dependencia 1   //////////
// ////////////////////////////////////////
function ReaddSitLine () {
	// F2.
	A = 0;
	do {
		ReaddSitLinep();
		Lines.attachMovie("SitLine", "Line"+A, A);
		C = eval("SitID"+A);
		set (B+".SitID", C);
		set (B+".SitVal", eval(C));
		set (B+".SitRep", eval(C+"Rep"));
		LinesBots.attachMovie("SitBots", "Bot"+A, A);
		ReaddSitLinep2();
	} while (A<SitElms);
}
function ReaddCond1Line () {
	// F4.
	A = 0;
	do {
		ReaddSitLinep();
		Lines.attachMovie("Cond1Line", "Line"+A, A);
		C = "Cond"+A;
		set (B+".Cond", A);
		set (B+".Elm1", eval(C+"Elm1"));
		set (B+".Comp", eval(C+"Comp"));
		set (B+".Elm2", eval(C+"Elm2"));
		LinesBots.attachMovie("Cond1Bots", "Bot"+A, A);
		ReaddSitLinep2();
	} while (A<Conds);
}
function ReaddCond2Lines () {
	// F6.
	A = 0;
	do {
		ReaddSitLinep();
		Lines.attachMovie("Cond2Line", "Line"+A, A);
		C = "Grup"+A;
		set (B+".Grup", A);
		set (B+".p1", eval(C+"p1"));
		set (B+".p2", eval(C+"p2"));
		set (B+".p3", eval(C+"p3"));
		set (B+".p4", eval(C+"p4"));
		set (B+".p5", eval(C+"p5"));
		set (B+".p6", eval(C+"p6"));
		set (B+".p7", eval(C+"p7"));
		set (B+".p8", eval(C+"p8"));
		set (B+".p9", eval(C+"p9"));
		set (B+".p10", eval(C+"p10"));
		set (B+".y1", eval(C+"y1"));
		set (B+".y2", eval(C+"y2"));
		set (B+".y3", eval(C+"y3"));
		set (B+".y4", eval(C+"y4"));
		set (B+".y5", eval(C+"y5"));
		set (B+".y6", eval(C+"y6"));
		set (B+".y7", eval(C+"y7"));
		set (B+".y8", eval(C+"y8"));
		set (B+".y9", eval(C+"y9"));
		set (B+".y10", eval(C+"y10"));
		LinesBots.attachMovie("Cond2Bots", "Bot"+A, A);
		ReaddSitLinep2();
	} while (A<Grups);
}
function ReaddCamLine () {
	// F8.
	A = 0;
	do {
		ReaddSitLinep();
		Lines.attachMovie("CamLine", "Line"+A, A);
		C = "Cam"+A;
		set (B+".Cond", eval(C+"Cond1"));
		set (B+".Elm", eval(C+"Elm"));
		set (B+".Elm1", eval(C+"Elm1"));
		set (B+".Op", eval(C+"Op"));
		set (B+".Elm2", eval(C+"Elm2"));
		C = 100*(A-1)*(A-1);
		setProperty (eval(B), _x, C);
		LinesBots.attachMovie("CamBots", "Bot"+A, A);
		set ("LinesBots.Bot"+A+".A", A);
		// En cada línea de bots, var que indica qué nro de linea es.
		setProperty ("LinesBots.Bot"+A, _x, C);
	} while (A<Cams);
}
// ////////////////////////////////////////
// /////   Add líneas y sus botones   /////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
function AddSitLine () {
	// Bot + en F2.
	SitElms = SitElms+1;
	B = "Lines.Line"+SitElms;
	Lines.attachMovie("SitLine", "Line"+SitElms, SitElms);
	set (B+".SitID", "Unrep"+SitElms);
	set (B+".SitVal", 5);
	set (B+".SitRep", "---");
	C = 23.4*(SitElms-1);
	setProperty (eval(B), _y, C);
	LinesBots.attachMovie("SitBots", "Bot"+SitElms, SitElms);
	set ("LinesBots.Bot"+SitElms+".A", SitElms);
	// En cada línea de bots, var que indica qué nro de linea es.
	setProperty ("LinesBots.Bot"+SitElms, _y, C);
	set ("SitID"+SitElms, "Unrep"+SitElms);
	set ("Unrep"+SitElms, 5);
	set ("Unrep"+SitElms+"Rep", "---");
	set ("Unrep"+SitElms+"Tipo", "RepBas");
	set ("Unrep"+SitElms+"Repis", "Max");
	set ("Unrep"+SitElms+"RepMin", 0);
	set ("Unrep"+SitElms+"RepMax", 5);
}
function AddCond1Line () {
	// Bot + en F4.
	Conds = Conds+1;
	B = "Lines.Line"+Conds;
	Lines.attachMovie("Cond1Line", "Line"+Conds, Conds);
	set (B+".Cond", Conds);
	set (B+".Elm1", "---");
	set (B+".Comp", "---");
	set (B+".Elm2", "---");
	C = 23.4*(Conds-1);
	setProperty (eval(B), _y, C);
	LinesBots.attachMovie("Cond1Bots", "Bot"+Conds, Conds);
	set ("LinesBots.Bot"+Conds+".A", Conds);
	// En cada línea de bots, var que indica qué nro de linea es.
	setProperty ("LinesBots.Bot"+Conds, _y, C);
	set ("Cond"+Conds+"Elm1", "---");
	set ("Cond"+Conds+"Comp", "---");
	set ("Cond"+Conds+"Elm2", "---");
}
function AddCond2Line () {
	// Bot + en F6.
	Grups = Grups+1;
	B = "Lines.Line"+Grups;
	Lines.attachMovie("Cond2Line", "Line"+Grups, Grups);
	set (B+".Grup", Grups);
	set (B+".p1", "---");
	set (B+".p2", "---");
	set (B+".p3", "---");
	set (B+".p4", "---");
	set (B+".p5", "---");
	set (B+".p6", "---");
	set (B+".p7", "---");
	set (B+".p8", "---");
	set (B+".p9", "---");
	set (B+".p10", "---");
	set (B+".y1", "---");
	set (B+".y2", "---");
	set (B+".y3", "---");
	set (B+".y4", "---");
	set (B+".y5", "---");
	set (B+".y6", "---");
	set (B+".y7", "---");
	set (B+".y8", "---");
	set (B+".y9", "---");
	set (B+".y10", "---");
	C = 23.4*(Grups-1);
	setProperty (eval(B), _y, C);
	LinesBots.attachMovie("Cond2Bots", "Bot"+Grups, Grups);
	set ("LinesBots.Bot"+Grups+".A", Grups);
	// En cada línea de bots, var que indica qué nro de linea es.
	setProperty ("LinesBots.Bot"+Grups, _y, C);
	set ("Grup"+Grups+"p1", "---");
	set ("Grup"+Grups+"p2", "---");
	set ("Grup"+Grups+"p3", "---");
	set ("Grup"+Grups+"p4", "---");
	set ("Grup"+Grups+"p5", "---");
	set ("Grup"+Grups+"p6", "---");
	set ("Grup"+Grups+"p7", "---");
	set ("Grup"+Grups+"p8", "---");
	set ("Grup"+Grups+"p9", "---");
	set ("Grup"+Grups+"p10", "---");
	set ("Grup"+Grups+"y1", "---");
	set ("Grup"+Grups+"y2", "---");
	set ("Grup"+Grups+"y3", "---");
	set ("Grup"+Grups+"y4", "---");
	set ("Grup"+Grups+"y5", "---");
	set ("Grup"+Grups+"y6", "---");
	set ("Grup"+Grups+"y7", "---");
	set ("Grup"+Grups+"y8", "---");
	set ("Grup"+Grups+"y9", "---");
	set ("Grup"+Grups+"y10", "---");
}
// ////////////////////////////////////////
// ///   Remove líneas y sus botones   ////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
function RemoveSitLine () {
	// Bot - en F2.
	if (SitElms>1) {
		removeMovieClip ("Lines.Line"+SitElms);
		removeMovieClip ("LinesBots.Bot"+SitElms);
		SitElms = SitElms-1;
	}
}
function RemoveCond1Line () {
	// Bot - en F4.
	if (Conds>1) {
		removeMovieClip ("Lines.Line"+Conds);
		removeMovieClip ("LinesBots.Bot"+Conds);
		Conds = Conds-1;
	}
}
function RemoveCond2Line () {
	// Bot - en F6.
	if (Grups>1) {
		removeMovieClip ("Lines.Line"+Grups);
		removeMovieClip ("LinesBots.Bot"+Grups);
		Grups = Grups-1;
	}
}

Muestra:
https://dl.dropboxusercontent.com/u/...55_muestra.swf

Nota: Hay varias cosas que están a medio hacer ergo no andan bien quizá. Por ejemplo la lista que se despliega en Condiciones parte 1 al cliquear Elemento. Pero los botones y cosas de las que hablo en el topic andan bien.

[agleiva]

No entiendo de qué estás hablando, ni lo que hace tu código (intenté leerlo pero me hace doler los ojos sinceramente), pero en general para definir cómo unificar y separar el código se utiliza el Principio de Responsabilidad Individual, conocido como SRP por su nombre en inglés.

http://en.wikipedia.org/wiki/Single_...lity_principle

Además de otros principios como Separation of Concerns, SOLID, etc.

[Tachikomaia]

Pues yo no entiendo el artículo que me diste xD Lo puse en español pero no sé a qué se refiere responsabilidad ni clase. Dice ser POO, pero yo no uso POO, creo.

Mi código está también en pseudocódigo e incluso puse una muestra. ¿Entiendes por qué no lo entiendes? Te pregunto porque en verdad lo que me has pasado ni siquiera entiendo por qué no lo entiendo, supongo que es por lo que dije de "responsabilidades" y demás.

Básicamente (mi código) cuando hay que reagregar líneas (cuando se llega a cierta sección, si ves la muestra ves los botones para cambiar de sección) lo que hace es agregar las líneas correspondientes a la sección y transmite en ellas variables ubicadas en la raíz, variables correspondientes a la sección.
Cuando de agregar líneas se trata (cuando se presiona el botón +) agrega 1 línea según la sección que corresponde y crea variables en ella y también en la raíz.
Cuando quita líneas (botón -), eso, quita líneas y además disminuye una variable según qué tipo de línea esté quitando.

También agrega o quita botones para las líneas, pero es más o menos igual a lo que haga con las líneas.

[agleiva]

Iniciado por Tachikomaia

Pues yo no entiendo el artículo que me diste xD Lo puse en español

Una vez más te digo: "si te interesa programar de verdad...", te conviene aprender inglés. La mayoría de la literatura, documentación y ejemplos de código de calidad profesional, sin importar el lenguaje o la plataforma, están en inglés.

Un ejemplo de esto es Stackoverflow.com. Ahí vas a encontrar preguntas y respuestas para todo tipo de lenguajes de programación y plataformas, con ejemplos de código, muchas veces escritos por programadores expertos, o autoridades en el tema, por ejemplo el/los creador/es de un cierto lenguaje o plataforma respondiendo sobre su propia plataforma.

Iniciado por Tachikomaia

¿Entiendes por qué no lo entiendes?

Si. No entiendo tu código por varias razones:

1 - Todo tu código está desordenado, mal indentado, carece completamente de estructura, prolijidad, coherencia y cohesión. Básicamente es un desastre.

2 - Estás usando una cantidad absurda de identificadores y no explicas en ningún momento qué son. No tengo idea de qué representa "Lines.Line"+A o qué hace la instrucción set (B+".SitVal", eval(C+"Rep")); porque no explicas qué es B, ni SitVal, ni C, ni Rep.

3 - Tus comentarios no tienen absolutamente nada que ver con nada. Por ejemplo esto:

// p es parte; también usada por Func ReaddCond1Line
// ReaddCond2Lines, ReaddCamLine
A = A+1;
B = "Lines.Line"+A;

Estás hablando de "p", pero no hay ningún identificador "p" en ningún lado en ese código. Tu comentario es completamente irrelevante e incomprensible.

4 - Usas nombres de variables totalmente indescriptivos como "A", "B", "C" que nadie jamás aparte de vos mismo puede tener idea de qué representan.

5 - Todo tu código tiene muy poco sentido, en general. "no va a ningún lado". No "hace nada". Solo declaras variables sin ninguna estructura, declarás funciones que no está claro cual es el objetivo de cada una, y en general no se entiende qué es lo que estás tratando de hacer.

Me hacés acordar al abuelo Simpson cuando se pone a contar que tenía una cebolla en el cinturón. Es decir, tus planteos y tu código son un sinfin de divagues sin relación, al mejor estilo del rock alternativo empastillado, o de la abuela con alzheimer.

Iniciado por Tachikomaia

lo que me has pasado ni siquiera entiendo por qué no lo entiendo

Nuevamente te repito, no entendés conceptos que son totalmente básicos y elementales en la programación, porque:

1 - Estás tratando de programar sobre una plataforma que no está pensada para programar demasiado, y esto afecta tu habilidad para razonar los problemas en una forma abstracta, estructurada, concreta, algorítmica, **programática**.

2 - estás haciendo un esfuerzo enorme para tratar de "programar sin aprender programación". Te negás a aprender cualquier cosa que esté fuera de tu marco de referencia actual, lo cual para ser honesto me parece una actitud bastante necia. Te conviene "salir de tu cajita" y ver como es el mundo realmente.

No entiendo bien cuál es la ganancia que pretendes obtener con esto. En general te recomendaría que te replantees tu actitud, porque si por ejemplo te vas a subir a un auto y tratar de manejar, al mismo tiempo que te negás a aprender a manejar como corresponde, lo más probable es que te estampes contra un árbol o un poste de luz.

Iniciado por Tachikomaia

Básicamente (mi código) cuando hay que reagregar líneas (cuando se llega a cierta sección, si ves la muestra ves los botones para cambiar de sección) lo que hace es agregar las líneas correspondientes a la sección y transmite en ellas variables ubicadas en la raíz, variables correspondientes a la sección.
Cuando de agregar líneas se trata (cuando se presiona el botón +) agrega 1 línea según la sección que corresponde y crea variables en ella y también en la raíz.
Cuando quita líneas (botón -), eso, quita líneas y además disminuye una variable según qué tipo de línea esté quitando.
También agrega o quita botones para las líneas, pero es más o menos igual a lo que haga con las líneas.

Esto que escribís reafirma lo que te dije antes sobre tu marco de referencia. Como lo único que conocés son "variables" y "líneas" y "botones", tratás de relacionar estos conceptos para armar una solución a tu problema. Tus herramientas mentales son muy escasas, y por eso estás hace años dando vueltas sobre lo mismo. Y encima de todo hablás con palabras que son desconocidas para la mayoría de los programadores, porque tu "mapa mental" de lo que es programar tiene poco que ver con lo que realmente es programar.

Es por esto que muchos de tus posts no los responde nadie

http://www.forosdelweb.com/f16/ven-algun-error-1100488/
http://www.forosdelweb.com/f2/dimens...usion-1101658/
http://www.forosdelweb.com/f16/esta-...-solo-1104928/

básicamente porque nadie entiende qué car*jo estás haciendo, ni por qué car*jo lo estás haciendo con flash. Y las pocas respuestas que obtenés son del tipo "dejate de joder con flash", "ponete a leer", etc.

Por último, y como te dije antes, te estas rompiendo el cerebro para tratar de desarmar el motor del auto con un cepillo de dientes. No se trata de nuevo o viejo, se trata de que Flash NO ESTA PENSADO PARA PROGRAMAR. Punto. Si querés programar de verdad te conviene realmente olvidarte de todo lo que crees que sabes y empezar con la mente fresca y abierta en una plataforma adecuada.

En el tiempo que perdiste escribiendo todo ese código horrible podrías haber mirado en youtube algun tutorial de introduccion a la programacion o cualquier cosa por el estilo. Hacelo y después te vas a dar cuenta que no tiene absolutamente ningún sentido lo que estás haciendo.

[Kritik]

Yo no tengo ni idea de lo que significa ni he leido el artículo pero por el nombre diría que se refiere a fundamentos de programación. Maneras de estructurar tu codigo. Un codigo que se repite en muchas partes no esta bien estructurado. Pues esa parte repetida puede tener identidad propia y ser llamada desde donde se la necesite.
Por otra parte las personas leen primero lo primero y ultimo lo ultimo.

[agleiva]

Otra cosa:

Si mi actitud te parece hostil, te pido disculpas. No es mi intención ser hostil, pero realmente alguien te tiene que dar un cachetazo para que te despiertes. A la larga ¿quién te hizo más daño? ¿el que te dijo de mala manera estás equivocado, o el que con un tono amistoso te dejó seguir en tu error? Esto es como el cuento del traje del emperador.

Parecés un tipo bastante inteligente, pero lamentablemente estás encasillado y enclaustrado en una "caja" que no te va a llevar a ningún lado.

Otra cosa más:

Cualquier persona con dos dedos de frente dudaría antes de bajarse un ejecutable de DropBox linkeado por un desconocido en internet. Si tu código es muy largo para postearlo acá podés usar PasteBin, o mejor, como hacen los programadores de verdad, levantar un repo en GitHub y subir todo el código ahí.

Por último:

Si te interesa saber cómo haría yo para hacer algo así te explico, pero tenés que tener la mente abierta y tratar de no enmarcar todo en tu marco de referencia actual porque si no no vas a entender nada y va a ser una pérdida de tiempo para vos y para mí.

[Malenko]

@Tachikomaia: se puede saber que es lo que tendría que hacer tu código? Estamos aquí para intentar ayudar, no para ser adivinos. Si pones lo que tu llamas "un pseudocódigo", que en realidad no lo es, sin decir que es lo que pretendes, difícilmente podré saber si está bien o no.

Como ya te han comentado, aprende fundamentos de programación. Si no usas POO hay otras metodologías que podrías usar para tener un código legible. Y ya no solo tú código de programación: como te han remarcado, nadie te responde porque no te expresas bien y no se te entiende.

@agleiva: no veo en ningún sitio donde hayas respondido con una actitud hostil. Todo lo contrario, me parecen muy buenas respuestas.

[Kritik]

Sobre qué lenguaje utilizar para qué cosa cada uno que use el que le de la gana. No es cuestión de enfadarse porque alguien trabaje de manera diferente.

Si alguien quiere construir un decorado virtual 3D con c o con basic cuando existen lenguajes específicos para eso pues sus razones tendrá.

Si alguien quiere fregar el suelo con un trapo en vez de con una fregona pues sus razones tendrá. Y si pide ayuda en un foro sobre trapos de como se usa un trapo pues... por qué criticarle?

Como bien dices en tro post ya se le ha comunicado al usuario que aquí nos pregunta que flash es para lo que es. Sin embargo el ha encontrado la manera de usarlo para otra cosa aunque flash no haya sido pensado para ello. Pues déjale que continue.si sabes de flash le ayudas y si no pues no.

Estoy seguro de que este chico sabe de la existencia de la fregona. Pero si aun quiere por alguna razón que tu no sabes seguir usando un trapo para el suelo pues deha que siga.

Cuando el que programa un decorado 3D para moverse por el vea el rendimiento de su resultado con el rendimiento y esfuerzo necesario en hacer un escenario mas grande y con mas detalles y definición construidos por un lenguaje para 3D quizá cambie o modifique sus programas. Que quizá tengan cosas que de ninguna otra forma pueda conseguir. Pero quizá tambien aprenda a combinar lenguajes y sacar lo mejor de cada 1.

En definitiva: vive y deja vivir. Aconseja pero no impongas.

[agleiva]

Iniciado por Kritik

No es cuestión de enfadarse porque alguien trabaje de manera diferente.

Yo no me "enfadé" en ningún momento. De hecho explícitamente pedí disculpas si mi respuesta resulta hostil.

Además, mi respuesta fue a la pregunta de por qué no entiendo el código de este post. Y por eso expliqué que no entiendo el código porque basicamente es un asco.

Iniciado por Kritik

Si alguien quiere construir un decorado virtual 3D con c o con basic cuando existen lenguajes específicos para eso pues sus razones tendrá.

Si, pero mi respuesta ni siquiera se centra en el lenguaje de programación, si no más bien en la mentalidad y el marco de referencia terriblemente acotado que está planteando.

Además, estoy tratando realmente de ayudarlo, ayudarlo a entender que no tiene ningún sentido lo que está haciendo. Vuelvo a hacer referencia al "traje del emperador". Prefiero que se enoje porque le digo la verdad y no que me sonría por ser complaciente y mentirle.

[Tachikomaia]

Iniciado por agleiva

Una vez más te digo: "si te interesa programar de verdad...", te conviene aprender inglés. La mayoría de la literatura, documentación y ejemplos de código de calidad profesional, sin importar el lenguaje o la plataforma, están en inglés.

Supongo, pero bueno uno tiene sus límites. O sea, inglés era la materia con más nota que tenía. Y más de uno se sorprende porque miro cosas con subtítulos en inglés o juego juegos en ese idioma. Ya sé que eso no significa que "ya sé inglés", sólo digo que... si con eso no alcanza.... entonces es pedirme demasiado, no llego.

1 - Todo tu código está desordenado, mal indentado, carece completamente de estructura, prolijidad, coherencia y cohesión.

Explica por qué dices esas cosas.

-----------------

Desordenado:
Las funciones que reagregan líneas están después del cuadro grande que dice "Readd líneas y sus botones", y son las únicas que están entre ese cuadro y otros. A su vez, las funciones allí están divididas en 2 grupos: Dependencia 0 y Dependencia 1.
Esa sección, esas funciones, que son las 1eras en aparecer e el código, son las 1eras que hice de las que mostré, y son las 1eras en usarse en el programa (salvo que presiones los botones + o -).
Te puedo hablar de las demás, pero has dicho"Todo tu código está desordenado", así que con esto debería alcanzar, ya que al menos eso que describí está ordenado, pero dudo que te alcance, ya deberías haber notado el orden pero si no lo notaste, será porque tienes un concepto diferente y habrá que verlo. Pero con todo el respeto del mundo ¿cómo sé que no me estás tomando el pelo o algo? Porque parece ser el caso. Si no hubiera puesto los cuadros o hubiera desparramado las funciones sin clasificación alguna, vale, habría desorden, te daría la razón. Pero si habiéndolas clasificado como he descrito dices que está todo desordenado...

-----------------

Indentación:
"Este término significa mover un bloque de texto hacia la derecha insertando espacios o tabuladores, para así separarlo del margen izquierdo y mejor distinguirlo del texto adyacente; en el ámbito de la imprenta, este concepto siempre se ha denominado sangrado o sangría."

No conocía el término, pero es claro y yo lo tengo así, pero en el post aparece mal ¿cómo hago para que aparezca bien?

Otra cosa que puede haber ocurrido es que el espacio aumentó, lo cual no es culpa mía tampoco, si sucede cuando lo pego en otro lado.

-----------------

Estructura:
Dices que carece completamente de ella. Wow, si un genio se propusiera lograr tal nivel de imperfección creo que no lograría mi hazaña. Para mí la estructura está relacionada con la organización, que ya describí, pero googlé por las dudas y encontré esto:
http://es.wikipedia.org/wiki/Estructura_de_datos
No entiendo bien lo que dice pero parece que es definir las variables dentro de "algo".

Código:

 Estruc Estructura,Miembro1:Entero,Miembro2:Cadena,Miembro3:Byte
 Var Variable:Estructura
 Variable.Miembro1 = 40000
 Variable.Miembro2 = "Hola Mundo"
 Variable.Miembro3 = 255
 Mensaje(Variable.Miembro2) ' Muestra "Hola Mundo"

Yo lo haría así:
Miembro1 = 40000
Miembro2 = "Hola Mundo"
Miembro3 = 255

Lo que dice mensaje no entiendo qué es. Si hay que mostrar un mensaje uso trace -en javascript creo que es alert- o creo un cuadro de texto que muestre una variable y modifico esa variable lo cual hace que el texto se modifique también.

¿Por qué es tan importante "la estructura"? ¿lo que dices está relacionado con el artículo que puse o no? ¿con esto
http://es.wikipedia.org/wiki/Dise%C3%B1o_estructurado
?
Ahí dice muchas cosas, yo no tengo idea y nunca tuve que usarlas. Aprendí con Basic y lo único que se hacía era asignar acciones en cierto orden. A veces repeticiones, a veces "ir a", lo cual se dice que no debe hacerse pero si me sirve lo hago y punto, no es un delito. Nunca necesité "definir variables sin apoyar los codos en la mesa", ni cursilerías como esas.

-----------------

Prolijidad:
Me suena a algo subjetivo. Pero está organizado. En el pseudocódigo definí las funciones usando _ cuando había palabras diferentes, es decir podría haberlas escrito todas seguidas pero no, intenté ser prolijo, no obstante se dice que mi código carece totalmente de prolijidad. En mi código no sé si se pueden usar _ pero cuando hay 2 palabras importantes les puse mayúscula. Etc.

¿Qué más se pretende?

-----------------

Coherencia:
Dices que no hay, bueno, tenés razón, el programa no funciona o funciona de forma totalmente inesperada, tenés razón.

-----------------

Cohesión:
http://es.wikipedia.org/wiki/Dise%C3...#Cohesi.C3.B3n
Parece ser independencia. Aunque en mi caso no sé si se trata de módulos. Mis funciones tienen independencia respecto a otras y si no la tienen es porque esa otra es una parte que se usa también en otras funciones.
Ej:
Función 1:
Oscurecer pantalla
Ocultar botones
Agregar ventana tipo Lista

Función 2:
Oscurecer pantalla
Ocultar botones
Agregar ventana tipo Operadores

Función 3:
Oscurecer pantalla
Ocultar botones
Agregar ventana tipo Comparadores

Llegado ese punto pienso que resulta conveniente crear una función para las partes que se repiten en cada función. Luego tendré 4 funciones de las cuales 3 dependerán de 1.

¿Cual es el problema?

2 - Estás usando una cantidad absurda de identificadores y no explicas en ningún momento qué son. No tengo idea de qué representa "Lines.Line"+A o qué hace la instrucción set (B+".SitVal", eval(C+"Rep")); porque no explicas qué es B, ni SitVal, ni C, ni Rep.

Me parece que es irrelevante, lo importante es si se pueden unir las funciones o no... Cuando los identificadores de cada función son diferentes eso quiere decir que esa parte de las funciones no se puede unir o que si se puede sería con eval o algo por el estilo. Como tú mismo dices son bastantes y me tomaría bastante -no más que responderte, eso sí- decirlo. Además he puesto el pseudocódigo.

Mira cuando hay un . significa que hay algo contenido. Por ejemplo Lines.Line significa que Line está contenido en Lines. O sea una película está contenida en otra. Le digo objetos suponiendo que era más claro, pero a estas alturas no sé.

Las comillas significa que no cambia, el A es sustituído por el valor de dicha variable y al sumarse queda Lines.Line1 por ejemplo si A es 1.

Cada línea que se agrega tiene un nombre diferente.

Tú mismo dices que no entiendes, y yo entiendo, a mí por ahí me pasaría lo mismo, pero no creo que haya que entender tanto, detalladamente.

La instrucción que mencionas set (B+".SitVal", eval(C+"Rep")) no existe. Es esta:
set (B+".SitVal", eval(C));
o esta:
set (B+".SitRep", eval(C+"Rep"));

B está definida. Capáz que no leíste desde la Dependencia 0 como había comentado. Y por ahí debí decir que ese tipo de variables (A, B, C, etc) tienen un uso variable o sea son contadores o abreviadores o copias de un resultado para no calcular de nuevo. Pensé que se darían cuenta de eso, ahí sí por ahí reconozco mi error, pero también es que quería evitar extenderme.

B es "Lines.Line"+A o sea una referencia a la ubicación de las variables. Es como si eso fuese una dirección en la computadora C:\Windows\Carpeta1.

SitVal es el nombre de una de las variables. Como ves tiene un . adelante o sea está dentro de una película.

C también está definida:
C = eval("SitID"+A);

Te lo puedo explicar pero creo que es irrelevante en la cuestión. El resultado puede ser "H1", "V2", etc.

Rep está relacionado con representación y se usa en varios sitios esa palabra (Rep), no es tan sencillo explicarlo y tampoco creo que sea tan relevante.

3 - Tus comentarios no tienen absolutamente nada que ver con nada. Por ejemplo esto:

// p es parte; también usada por Func ReaddCond1Line
// ReaddCond2Lines, ReaddCamLine
A = A+1;
B = "Lines.Line"+A;

Estás hablando de "p", pero no hay ningún identificador "p" en ningún lado en ese código. Tu comentario es completamente irrelevante e incomprensible.

Porque no leíste bien y/o a propósito no citaste lo que está antes del comentario:

function ReaddSitLinep () {
// p es parte; también usada por Func ReaddCond1Line
// ReaddCond2Lines, ReaddCamLine

4 - Usas nombres de variables totalmente indescriptivos como "A", "B", "C" que nadie jamás aparte de vos mismo puede tener idea de qué representan.

He dicho el motivo ahora, más arriba, pero en eso sí te doy bastante razón.

5 - Todo tu código tiene muy poco sentido, en general. "no va a ningún lado". No "hace nada". Solo declaras variables sin ninguna estructura, declarás funciones que no está claro cual es el objetivo de cada una, y en general no se entiende qué es lo que estás tratando de hacer.

¿Has visto la muestra? Ok, dame un tiempo y te voy a dar diferentes muestras, cada una con una función faltante, diferente cada una, y si así no ves lo que hacen -y por qué son importantes en el programa- ya no es mi problema xP

Lo que hacen está escrito en el cuadro del código (Readd/Add/Remove líneas, y son 3 cuadros diferentes no es que estén escritos así todos juntos), en el nombre de la función (ejemplo: ReaddSitLines reagrega lineas tipo situación), en el pseudocódigo y en la respuesta que te di. Y lo puedes ver en la muestra.

tus planteos y tu código son un sinfin de divagues sin relación

Suficiente, no volveré a leer lo que escribas.

Si alguien quiere hacer el favor de explicar las cosas que dijo el señor este, gracias, pero yo no pienso volver a leerlo porque estoy hasta la coronilla de leer expresiones ofensivas. Algunas tolero, pero tantas no. Esta no es la única, esta es la que derramó el vaso.

[Tachikomaia]

Iniciado por Kritik

Yo no tengo ni idea de lo que significa ni he leido el artículo pero por el nombre diría que se refiere a fundamentos de programación. Maneras de estructurar tu codigo. Un codigo que se repite en muchas partes no esta bien estructurado. Pues esa parte repetida puede tener identidad propia y ser llamada desde donde se la necesite.

Ahí va, eso es lo que intento mejorar. El artículo habla de muchas cosas que no conozco, no siento que lo haya comprendido, no sé.

Por otra parte las personas leen primero lo primero y ultimo lo ultimo.

Pero lo 1ero a veces está en la derecha -mangas- o de una forma poco usual que quien escribe avisa.

[Tachikomaia]

Iniciado por Malenko

@Tachikomaia: se puede saber que es lo que tendría que hacer tu código?

¿Has leeído el pseudocódigo? ¿has visto la muestra?

Si pones lo que tu llamas "un pseudocódigo", que en realidad no lo es

Lo llamo "pesudicódigo simple", pero dime por qué no es pseudocódigo.

, sin decir que es lo que pretendes, difícilmente podré saber si está bien o no.

Es difícil explicarlo. Pero creo que es bastante irrelevante lo que pretendo en última instancia, lo que pretendo ahora con este tema es simplemente ver si las funciones se pueden unir para que no se repita tanto el código.

Te pongo el mismo ejemplo que le puse al otro:

Función 1:
Oscurecer pantalla
Ocultar botones
Agregar ventana tipo Lista

Función 2:
Oscurecer pantalla
Ocultar botones
Agregar ventana tipo Operadores

Función 3:
Oscurecer pantalla
Ocultar botones

Suponte que te pregunto si ahí me conviene unir funciones y cómo lo haría. Supongo que en ese caso no me preguntarías qué es lo que quiero hacer. "¿Qué botones son?", "¿qué es tipo lista?", etc, no creo que sea necesario detallar eso.

tener un código legible

La próxima vez preguntaré sobre eso.

no te expresas bien

Y sobre eso.

En qué sección del foro los abro?

[agleiva]

Iniciado por Tachikomaia

¿Has leeído el pseudocódigo? ¿has visto la muestra?

Capo tenés un concepto equivocado de como funciona un foro de Internet. La gente no puede leerte la mente y NADIE se va a pasar 3 horas intentando entender que c*rajo quisite hacer, a menos que presentes código prolijo, bien formateado, bien estructurado, y tus planteos sean claros y concisos.

Y ya te dije, la gente no va a clickear en tu archivito de Flash porque nadie sabe si le metiste un virus, si al abrirlo borra todos los archivos del disco rigido, o le transmite mis credenciales de Windows a alguien.

Si querés que la gente te tome enserio abrite un repositorio en GitHub y poné tu código ahí.

Con respecto a todo lo demás. ¿Querés que te conteste o no? No me hagas gastar los dedos tipeando si no te interesa aprender.

[Malenko]

Iniciado por Tachikomaia

Es difícil explicarlo. Pero creo que es bastante irrelevante lo que pretendo en última instancia, lo que pretendo ahora con este tema es simplemente ver si las funciones se pueden unir para que no se repita tanto el código.

Una cosa es que tú lo consideres irrelevante y otro que lo sea. Pero si quieres seguir escribiendo así, este tema terminará como el resto: sin respuesta y terminando en una serie de desvaríos que no tienen nada que ver con la petición inicial.

[Tachikomaia]

De mi programa estoy revisando y modificando bastantes cosas, voy a tardar en revisar mejor las funciones pero estas:

Código:

// ////////////////////////////////////////
// ///   Remove líneas y sus botones   ////
// ////////////////////////////////////////
// ///////////   Dependencia 0   //////////
// ////////////////////////////////////////
function RemoveSitLine () {
	// Bot - en F2.
	if (SitElms>1) {
		removeMovieClip ("Lines.Line"+SitElms);
		removeMovieClip ("LinesBots.Bot"+SitElms);
		SitElms = SitElms-1;
	}
}
function RemoveCond1Line () {
	// Bot - en F4.
	if (Conds>1) {
		removeMovieClip ("Lines.Line"+Conds);
		removeMovieClip ("LinesBots.Bot"+Conds);
		Conds = Conds-1;
	}
}
function RemoveCond2Line () {
	// Bot - en F6.
	if (Grups>1) {
		removeMovieClip ("Lines.Line"+Grups);
		removeMovieClip ("LinesBots.Bot"+Grups);
		Grups = Grups-1;
	}
}

Creo que sé cómo unirlas.

Actualmente los botones - simplemente llaman a la función que corresponda. Pero si lo hiciera así:

Código:

function RemoveSitLine () {
	// Bots -.
	B = eval(A);
	if (B>1) {
		removeMovieClip ("Lines.Line"+B);
		removeMovieClip ("LinesBots.Bot"+B);
		set (A, B-1);
	}
}

Botón - de F2:
_root.A = "SitElms";
_root.RemoveSitLine ();

Botón - de F4:
_root.A = "Conds";
_root.RemoveSitLine ();

Botón - de F6:
_root..A = "Grups";
_root.RemoveSitLine ();

Podría servir. Repito que por ahora no voy a revisar las funciones en el código porque estoy con otras partes. Tampoco es que esto solucione mi duda porque hay 2 grupos más.

[Malenko]

Una (muy) mala práctica que tienes es que desde una función modificas una variable externa. Lo correcto es pasar el valor como parámetro y obtener el nuevo valor como resultado de la función.

[Tachikomaia]

Bien, algo he oído sobre eso, pero aún no lo aprendí.

[gnzsoloyo]

Por definición, una función es un proceso que recibe cero o N parámetros y devuelve un único valor.
Y dentro de su código, no puede ni debe modificar variables fuera de su ámbito, de lo contrario deja de ser una función y se transforma en un subprocedimiento.