Vine a ampliar un tema que hice de videojuegos y me encontré con un privado diciéndome que me borraron un post de otro tema porque según la persona no tenía que ver con él.

Que borren cosas de política o incitaciones a la violencia lo entiendo, pero con eso y esto otro ya quitan las ganas de participar, no se puede hablar tranquilo, no se sabe cuando aparecerá alguno a borrar lo que escribas por a, por b, por c, etc ¿para qué escribir acá entonces? Te salís un poquito de la informática y te borran. Surgió un mini debate con Elektro sobre si está bien que pongan trabas a todos por culpa de algunos, algo que se hace en el foro, de hecho yo estaba defendiendo las reglas del foro y me borran el mensaje, bah.

En fin, pregunta del título. Pasen por privado. Si no les gusta el tema ciérrenlo, no lo borren please.

Un mod borró mi respuesta porque dijo que no tenía que ver con el tema. Quisiera que no me borren esto también, déjenme decir por qué no respondo (lo acabo de decir).

Cambié esto que estaba incompleto:

function VerSiColorFaltabaEtc () {
	// Esta función se usa en 2 lados distintos usando variables distintas,
	// por eso en algunos casos hay 2 traces casi iguales.
	// Esto puede cambiar:
	ColorFaltaba = "No";
	PunteroDeColores = 0;
	while (PunteroDeColores<Faltantes) {
		PunteroDeColores++;
		trace ("Comparando con el color guardado en el lugar "+PunteroDeColores+": "+eval("Faltante"+PunteroDeColores));
		if (ColorDeCuadradito.getRGB() == eval("Faltante"+PunteroDeColores)) {
			trace ("Iguales, el color del cuadradito recién agregado faltaba.");
			ColorFaltaba = "Sí";
			trace ("El cuadradito "+CuadraditosColocados+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
			trace ("El cuadradito "+CuadraditoaRepintar+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
			// Quitarlo de la lista de faltantes,
			// para eso sustituirlo por...
			// el último y borrar el último
			// (si el que debe borrarse es el último,
			// la sustitución es en vano pero...
			// el resultado el mismo,
			// sin necesidad de reordenar la lista)
			set ("Faltante"+PunteroDeColores, eval("Faltante"+Faltantes));
			Faltantes--;
			trace ("La cantidad de colores faltantes es "+Faltantes);
			// Para que no siga mirando la lista:
			PunteroDeColores = Faltantes;
		}
	}
	// Si el color no faltaba:
	if (ColorFaltaba == "No") {
		trace ("No faltaba, se verá si es uno de los únicos.");
		// Esto puede cambiar:
		ColorUnico = "Sí";
		PunteroDeColores = 0;
		while (PunteroDeColores<MenosDe2) {
			PunteroDeColores++;
			trace ("Comparando con el color guardado en el lugar "+PunteroDeColores+": "+eval("MenosDe2"+PunteroDeColores));
			if (ColorDeCuadradito.getRGB() == eval("MenosDe2"+PunteroDeColores)) {
				trace ("Iguales, el color del cuadradito recién agregado ya existía.");
				ColorUnico = "No";
				// Quitarlo de la lista de únicos,
				// para eso sustituirlo por...
				// el último y borrar el último
				// (si el que debe borrarse es el último,
				// la sustitución es en vano pero...
				// el resultado el mismo,
				// sin necesidad de reordenar la lista)
				set ("MenosDe2"+PunteroDeColores, eval("MenosDe2"+MenosDe2));
				MenosDe2--;
				trace ("La cantidad de colores únicos es "+MenosDe2);
				// Para que no siga mirando la lista:
				PunteroDeColores = MenosDe2;
			}
		}
		if (ColorUnico == "No") {
			trace ("El cuadradito "+CuadraditosColocados+" tiene un color ya existente: "+ColorDeCuadradito.getRGB());
			trace ("El cuadradito "+CuadraditoaRepintar+" tiene un color ya existente: "+ColorDeCuadradito.getRGB());
		}
	}
}
// Agregar, distribuir cuadraditos y asignarles un color,
// pero la cantidad de diferentes colores debe ser...
// la indicada por _level0.ColoresRequeridos. Por eso...
// se hace una lista de los colores faltantes y de...
// los presentes menos de 2 veces,
// y se irán eliminando en el futuro:
Faltantes = _level0.ColoresRequeridos;
MenosDe2 = _level0.ColoresRequeridos;
Colores = 0;
do {
	Colores++;
	set ("Faltante"+Colores, _level0.PosiblesColores[Colores-1]);
	set ("MenosDe2"+Colores, _level0.PosiblesColores[Colores-1]);
} while (Colores<_level0.ColoresRequeridos);
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Si el dibujo no tenía los colores necesarios:
	if (Faltantes>0) {
		trace ("El dibujo probablemente aún no tiene los colores requeridos, faltaban: "+Faltantes);
		trace ("Se colocó el cuadradito: "+CuadraditosColocados);
		trace ("Su color es: "+ColorDeCuadradito.getRGB());
		trace ("Se verá si es uno de los faltantes.");
		VerSiColorFaltabaEtc();
	}
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// Si es necesario, reasignar colores hasta lograr lo requerido:
while (Faltantes>0) {
	trace ("Se asignó color a todos los cuadraditos pero faltaron colores: "+Faltantes);
	trace ("Se volverán a asignar colores.");
	CuadraditoaRepintar = 0;
	do {
		CuadraditoaRepintar++;
		ColorDeCuadradito = new Color("Cuadradito"+CuadraditoaRepintar);
		ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
		VerSiColorFaltabaEtc();
	} while (CuadraditoaRepintar<_level0.MaxCuadradito);
}

Por esto simplificado que funciona mal:

// Agregar, distribuir cuadraditos y asignarles un color:
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Incrementar el contador de cuadraditos de ese color:
	Resumen = "Color"+ColorDeCuadradito;
	set(Resumen, eval(Resumen)+1);
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// El dibujo debe tener la cantidad de colores...
// indicada por _level0.ColoresRequeridos. Por eso,
// y por practicidad, se asignará a cuadraditos al azar,
// cada uno de los colores, evitando reelegir cuadraditos.
Colores = 0;
do {
	// Elegir cuadradito al azar:
	CuadraditoElegido = random(_level0.MaxCuadradito)+1;
	trace("CuadraditoElegido: "+CuadraditoElegido);
	// Ver si ya fue elegido:
	PunteroDeElegidos = 0;
	while (Colores>PunteroDeElegidos) {
		PunteroDeElegidos++;
		trace("Comparando con el "+PunteroDeElegidos+", que es: "+eval("Elegido"+PunteroDeElegidos));
		if (eval("Elegido"+PunteroDeElegidos) == CuadraditoElegido) {
			trace("Son iguales");
			// Ya elegido, repetir el proceso para elegir otro:
			Colores--;
			// Terminar este loop:
			PunteroDeElegidos = Colores;
		}
	}
	Colores++;
	// Guardar en la lista al cuadradito elegido:
	set("Elegido"+Colores, CuadraditoElegido);
	trace("El recién elegido fue guardado en: Elegido"+Colores);
	// Asignarle el color:
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditoElegido);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[Colores-1]);
	trace("Se le asignó el color "+_level0.PosiblesColores[Colores-1]);
	trace("La cantidad de colores asignada es "+Colores);
} while (Colores<_level0.MaxCuadradito);

Y lo arreglé así:

// Agregar, distribuir cuadraditos y asignarles un color:
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Incrementar el contador de cuadraditos de ese color:
	Resumen = "Color"+ColorDeCuadradito;
	set(Resumen, eval(Resumen)+1);
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// El dibujo debe tener la cantidad de colores...
// indicada por _level0.ColoresRequeridos. Por eso,
// y por practicidad, se asignará a cuadraditos al azar,
// cada uno de los colores, evitando reelegir cuadraditos.
Colores = 0;
do {
	// Elegir cuadradito al azar:
	CuadraditoElegido = random(_level0.MaxCuadradito)+1;
	trace("CuadraditoElegido: "+CuadraditoElegido);
	// Esto puede cambiar:
	ElegidoValido = "Sí";
	// Ver si ya fue elegido:
	PunteroDeElegidos = 0;
	while (Colores>PunteroDeElegidos) {
		PunteroDeElegidos++;
		trace("Comparando con el "+PunteroDeElegidos+", que es: "+eval("Elegido"+PunteroDeElegidos));
		if (eval("Elegido"+PunteroDeElegidos) == CuadraditoElegido) {
			trace("Repetido");
			// Ya elegido, repetir el proceso para elegir otro:
			ElegidoValido = "No";
			// Terminar este loop:
			PunteroDeElegidos = Colores;
		}
	}
	if (ElegidoValido == "Sí") {
		Colores++;
		// Guardar en la lista al cuadradito elegido:
		set("Elegido"+Colores, CuadraditoElegido);
		trace("El recién elegido fue guardado en: Elegido"+Colores);
		// Asignarle el color:
		ColorDeCuadradito = new Color("Cuadradito"+CuadraditoElegido);
		ColorDeCuadradito.setRGB(_level0.PosiblesColores[Colores-1]);
		trace("Se le asignó el color "+_level0.PosiblesColores[Colores-1]);
		trace("La cantidad de colores asignada es "+Colores);
	}
} while (Colores<_level0.ColoresRequeridos);

Ahora bien ¿es necesario ese último if? ¿el código anterior no puede funcionar bien sin eso? Lo hice intentando evitar ese if y lo tuve que usar igual, bah, creí que era posible ¿no lo es? ¿cómo sería posible?

En cuanto a qué es más eficiente, no lo sé, de esta forma se están asignando colores que puede que ya estén asignados y entonces es innecesario, pero la cantidad de colores que usaré es más bien poca así que el loop es corto y de la otra manera hay que usar más loops así que... Dudo que esto sea mala idea.

Está bien el ejemplo pero no se permite, en este país, entrar a supermercados con capucha puesta, lentes de Sol puestos, cascos puestos, las mochilas hay que dejarlas en casilleros, etc, tú sabrás por qué.

Quizá la solución sea que los moderadores puedan marcar temas como No editable, y los demás sí se puedan editar. O que se pueda si nadie respondió el tema.
O que todos sean no editables por defecto y los mods puedan marcar temas como editables, no sé cual de las 2 les quedaría más cómodo para ellos, pero para el usuario sería lo 1ero porque con esto cabría preguntar "Eh ¿por qué aún no lo marcaste como editable?".

Se acercan sólo si tú te acercas. Lo que digo sería que a penas sales del pueblo o llegas a un teletransportador, todos los que puedan acercarse lo hagan, y combatan. No me refiero a los que estén dentro de lugares apartados como mazmorras o Tristam, pero una vez que entres a una sería lo mismo, en lo posible.

¿Existe un mod para eso? ¿hay posibilidad de hacerlo?

He leído cosas pero sigo sin saber los detalles que busco.

Aquí por ejemplo hay info:
https://diablo2.diablowiki.net/Item_Generation_Tutorial

¿Cual es el ILV de los sets? En un sitio dice que el del Artic Gear es 3, pero los Artic Mitts son Light Gauntlets y ese tipo de ítems dice que tienen ILV 20, así que no sé.

En teoría, si un jugador tuviera mucha suerte ¿desde qué momento podría tener el Artic Gear completo?

Si se vence a un monstruo de LV10 por ejemplo ¿qué ítems puede dar? Me refiero a tipos (cap, hat, full hat, etc), a affixes y suffixes, a únicos y sets.

Además ese texto me resulta confuso.

Yo lo que sé es:
- Los ítems que aparecen en los comercios tienen hasta LV+5 comparados con el del personaje, pero en la dificultad normal tienen límites y parece que hay otros límites, no entiendo bien.
- El LV de los monstruos varía según el área y nivel de dificultad, salvo el de ciertos monstruos únicos.
- El Item Level depende del LV del monstruo vencido.
- Entre mayor sea el ILV, más probable es que el ítem sea mejor.

Y alguna otra cosa pero me resulta complicado. Voy a mirar guías de Game faq a ver si ahí lo explican más claro, lo que he visto por ahora para mí no.

Si tengo novedades sobre un tema, suelo publicarlas en una nueva respuesta. No más de 1, porque entiendo que el doble post no es del todo ético, y ni que hablar del triple o más.

Responder es más rápido que editar, no sólo porque no es necesario ir al fondo del mensaje, sino porque no es necesario poner EDIT o pasar una raya, etc. Además es más prolijo, más fácil de entender, la novedad en un nuevo post, separado.

Pero bueno, si es mejor, voy a empezar a editar en vez de responder. ¿Pero el tema vuelve a activos?
Acá:
https://foro.elhacker.net/unread.html;all
O si vuelve a arriba en la lista de temas. Me pregunto porque qué sentido tiene poner novedades en un tema que seguirá abajo como si ya hubieran visto todo de él.

¿Carisma? xD No sé, pero diría que un bot se reconoce porque escribe de un modo que parece aburrido, no sé explicarlo pero es como "uf, ya dará su lista", por ejemplo. Yo igual doy el beneficio de la duda, pero no sé qué sentido tiene usar un bot para responder cosas, el que quiera ver respuestas de un bot usa un bot, no un foro.

Lo empecé a hacer a mi manera y va bien así que ya no es importante, cualquier cosa le pregunto a GPT.

// Programa para contar cosas...
// relativas a contactos con escaleras.
// 1 condición:
function ContarPriIzq () {
	PriIzq++;
	PriIzqoDer++;
	PriIzqoArr++;
}
function ContarPriDer () {
	PriDer++;
	PriIzqoDer++;
	PriDeroArr++;
}
function ContarPriArr () {
	PriArr++;
	PriIzqoArr++;
	PriDeroArr++;
}
// Escalera 1:
Escalera1First = "Izq";
Escalera1Izq = 3;
Escalera1Der = 0;
Escalera1Arr = 0;
Escalera1Last = "Izq";
// 2:
Escalera2First = "Der";
Escalera2Izq = 0;
Escalera2Der = 2;
Escalera2Arr = 0;
Escalera2Last = "Der";
// 3:
Escalera3First = "Izq";
Escalera3Izq = 1;
Escalera3Der = 0;
Escalera3Arr = 0;
Escalera3Last = "Izq";
// 4:
Escalera4First = "Der";
Escalera4Izq = 2;
Escalera4Der = 1;
Escalera4Arr = 1;
Escalera4Last = "Izq";
// 5:
Escalera5First = "Arr";
Escalera5Izq = 1;
Escalera5Der = 0;
Escalera5Arr = 1;
Escalera5Last = "Izq";
// 6:
Escalera6First = "Der";
Escalera6Izq = 0;
Escalera6Der = 1;
Escalera6Arr = 0;
Escalera6Last = "Der";
// 7:
Escalera7First = "Izq";
Escalera7Izq = 1;
Escalera7Der = 0;
Escalera7Arr = 0;
Escalera7Last = "Izq";
//
Escalera = 0;
do {
	Escalera++;
	// Resumen:
	Res = "Escalera"+Escalera;
	// Contar escaleras contactadas 1ero por (lado):
	eval("ContarPri"+eval(Res+"First"))();
	Contactos = eval(Res+"Izq")+eval(Res+"Der")+eval(Res+"Arr");
	if (Contactos == 1) {
		// Contar escaleras contactadas sólo 1 vez:
		OneTime++;
	} else {
		// Más de 1 vez:
		SomeTimes++;
	}
} while (Escalera<7);

A ver, para plantear preguntas filosóficas digamos, sobre qué es ético hacer en X situación, o cual es la mejor forma de gobierno, o cosas así, usaba un foro que era de Filosofía o medio de eso. Empezó a haber cada vez menos usuarios, y con los que quedaban no parecía útil hablar, había por ejemplo un católico que decía fumar marihuana y recibir mensajes telepáticos de mujeres zoofílias, y en general él sólo hablaba de Dios. Me cansé de la Filosofía, asumí que era más bien para locos, me enfoqué en algo más tangible como la Programación.

A su vez, quiero escribir un libro que en lo posible lo pueda entender hasta una hormiga e intenté aprender Química, o me enfoqué un poco en eso luego de dejar el foro. Si no puede ser una hormiga, entonces un gato, sino un mono, sino un indígena, lo que se pueda. Aquí no tiene mucho sentido hablar de esas cosas ¿no? ¿dónde podía preguntar sobre estas cosas? Con GPT no podía hablar porque me pedía celular y sólo he tenido uno hace muchos años poco tiempo. Probé Redit pero en muchos casos me cerraban los temas y/o me tomaban el pelo, y me banearon, mientras que por email comencé a recibir mensajes sobre Quora aunque ni sabía qué era eso, lo empecé a usar y estuvo bien. Hay de todo, he recibido buenas respuestas y malas, a los que me toman el pelo los bloqueo y listo. Preguntas me llegan pocas, muchas veces de cosas que no sé, no las respondo, y si veo que alguien hace preguntas muy malas también lo bloqueo. Hay gente hablando de diversas cosas, publican cosas de la historia, chistes, etc. Y moderadores hay, o sea, muchas veces entré a una publicación y estaba eliminada, y cuando respondes en un espacio puede que no admitan tu respuesta. En la zona general también creo que hay moderación. Para mí está bien, de política también se puede hablar.

Había buscado foros de ciencia pero no hallé, los que hallé son cerrados, son más bien conferencias, no entendí bien, igual la ciencia no es lo mío... Conozco uno donde se puede hablar bien y está todo bien pero no es tanto de Química.

Yo empecé a usar Quora el año pasado, antes no sé cómo era, pero si mal no recuerdo decían que era mejor, al menos por un tiempo, probablemente esté decayendo luego de haber alcanzado su mejor momento. Me enteré que al haber tanta actividad los moderadores no dan a basto, pero en mi caso según recuerdo el único problema significativo que tuve es con un supuesto hacker que no sé si se desbloqueó luego de que lo bloqueé o sólo es que tiene muchas cuentas, pone su propaganda en mis preguntas, me llega notificación de una respuesta y resulta ser spam nada más. Pero es sólo él o su grupo.

Otro problema es que el mismo que responde o publica puede borrar comentarios, así que si miente es como que nadie lo puede indicar, su mentira puede llenarse de likes sin que nadie se entere de que es mentira. Pero lo bloqueas y ya, no se puede ganar siempre, ni vale la pena.

El tema del bloqueo no sé exactamente cómo funciona, se supone que si bloqueas a alguien ya no te puede responder o hablar, pero no estoy seguro porque también existe la opción de impedir que sigan hablando en una conversación particular, y quizá a alguien particular en una conversación, así que si no puedo hablar con alguien no sé si es que me bloqueó o sólo me censuró ahí. No he intentado hablar en otros lados con gente que me censuró en un lado.