Deberían agregar un ícono de confusión.

Esta es la salida:
Caminó a la derecha: 0.5
Caminó a la izquierda: 0
Caminó a la izquierda: -0.5
Caminó a la derecha: 0
Caminó a la derecha: 0.5
Caminó a la izquierda: 0
Caminó a la izquierda: -0.5
Mario empujado mientras caminaba a: -0.5
El EmpujeaDKMario es: 0
Distancia: 60.7
Empuje negativo, no debería ocurrir
Mario empujado mientras caminaba a: -0.5

y se repite. Esos mensajes indican la velocidad pixeles por frame, conque Mario se está moviendo, y la distancia respecto a Donkey Kong, que está a su derecha, moviéndose hacia él:
Mario <-DK
Los mensajes de movimientos son sobre Mario.

La velocidad de ambos es 0.5. Así que... voy a poner que la distancia se muestre más seguido, pero no es un error que pueda obtener a voluntad.

Distancia: 57.8
Mario empujado mientras caminaba a: 0.5
El EmpujeaDKMario es: 2.93
Moving por ser empujado: -2.43
Caminó a la derecha contra gran empuje: -2.4007
Distancia: 59.75
Mario empujado mientras caminaba a: -2.4007
El EmpujeaDKMario es: -5.569051
Empuje negativo, no debería ocurrir

Casi seguro que es cuando presiono izquierda justo antes de que sea empujado o en el mismo momento.

No puedo explicar lo que no entiendo, pero quedan tan cerca que hay colisión, cuando Mario caminaba a la derecha, así que es empujado a la izquierda, bastante, no debería haber colisión de nuevo en ese momento, pero hay... ¿por qué?

¿Cómo lo puedo entender más?

Viendo mensajes que no puse (son muchas líneas que parecen irrelevantes) veo que con 58.8 no ocurre colisión:
Distancia: 59.8
Distancia: 58.8
Distancia: 57.8
Mario empujado mientras caminaba a: 0.5
...pero en lo que puse antes dice que se detectó a 59.75, o sea, a mayor distancia sí se detectó colisión, no puede ser. Les dejo lo que me parece relevante del código, espero no resumir de más. Ah, un detalle: Cuando Mario es empujado, su velocidad tarda en normalizarse, dependiendo de si camina contra el empuje, si se queda quieto o camina a favor, pero dudo que eso sea la causa del problema, creo que es en la parte de DK.

// Player:
attachMovie("sDKMario", "Player", 1001);
setProperty ("Player", _x, 620);
setProperty ("Player", _y, 568);
// Velocidad conque se está moviendo y dirección:
Player.Moving = 0;
DKMarioSpeed = 0.5;
// IA:
attachMovie("sDK", "IA", 1000);
setProperty ("IA", _x, 780);
setProperty ("IA", _y, 568);
IA.Moving = 0;
DKSpeed = 0.5;
// /////////////////////////////////////////////
// //////////////////  Most  ///////////////////
// /////////////////////////////////////////////
// Nota: Creo que no estoy usando esto:
function FrenoPorFriccion (ID, Character) {
	if (Math.abs(eval(ID+".Moving")) > eval(Character+"Speed")) {
		set(ID+".Moving", (eval(ID+".Moving")+eval(Character+"Speed")*eval(ID+".Facing"))/2);
	}
}
// /////////////////////////////////////////////
// //////////////////  Mario  //////////////////
// /////////////////////////////////////////////
function WalkToRight () {
	// Si no está empujado a la derecha con más velocidad a la propia:
	if (Player.Moving < DKMarioSpeed) {
		// Si no está empujado a la izquierda con más velocidad a la propia:
		if (Player.Moving >= -DKMarioSpeed) {
			// Aumenta su velocidad hacia la derecha sin exceder el máximo:
			Player.Moving = Math.min(DKMarioSpeed, Player.Moving+DKMarioSpeed);
			trace("Caminó a la derecha: "+Player.Moving);
		} else {
			// Aumenta su velocidad un poco hacia la derecha sin exceder el máximo:
			Player.Moving = Math.min(DKMarioSpeed, (Player.Moving*99+DKMarioSpeed)/100);
			trace("Caminó a la derecha contra gran empuje: "+Player.Moving);
		}
	} else if (Player.Moving > DKMarioSpeed) {
		// Reducción de la velocidad:
		Player.Moving = (Player.Moving*99+DKMarioSpeed)/100;
		trace("Derecha con empuje: "+Player.Moving);
	}
	Player._x = Player._x+Player.Moving;
}
function WalkToLeft () {
	// Si no está empujado a la izquierda con más velocidad a la propia:
	if (Player.Moving > -DKMarioSpeed) {
		// Si no está empujado a la derecha con más velocidad a la propia:
		if (Player.Moving <= DKMarioSpeed) {
			// Aumenta su velocidad hacia la izquierda sin exceder el máximo:
			Player.Moving = Math.max(-DKMarioSpeed, Player.Moving-DKMarioSpeed);
			trace("Caminó a la izquierda: "+Player.Moving);
		} else {
			// Esto no ocurre por ahora (haber sido empujado a la derecha).
		}
	} else if (Player.Moving < -DKMarioSpeed) {
		// Reducción de la velocidad:
		Player.Moving = (Player.Moving*99-DKMarioSpeed)/100;
		trace("Izquierda con empuje: "+Player.Moving);
	}
	Player._x = Player._x+Player.Moving;
}
function Frenar () {
	if (Player.Moving > DKMarioSpeed) {
		// Si está moviéndose a la derecha más rápido de lo normal
		// (porque está empujado), poca reducción de la velocidad:
		Player.Moving = 0.99*Player.Moving;
		trace("Frenando naturalmente: "+Player.Moving);
		Player._x = Player._x+Player.Moving;
	} else if (Player.Moving < -DKMarioSpeed) {
		// Si está moviéndose a la izq más rápido de lo normal
		// (porque está empujado), poca reducción de la velocidad:
		Player.Moving = 0.99*Player.Moving;
		trace("Frenando naturalmente: "+Player.Moving);
		Player._x = Player._x+Player.Moving;
	}
}
// /////////////////////////////////////////////
// ///////////////////  DK  ////////////////////
// /////////////////////////////////////////////
function DKVsDKMario () {
	Distancia = IA._x-Player._x;
	trace("Distancia: "+Distancia);
	if (Distancia > 0) {
		// DK está a la derecha de Mario:
		IA._x = IA._x-DKSpeed;
		if (IA.hitTest(Player)) {
			if (Player.Action2 == "Walking") {
				EmpujeaDKMario = (DKSpeed+Player.Moving)*((DKPeso-DKMarioPeso)/100);
				trace("Mario empujado mientras caminaba a: "+Player.Moving);
				trace("El EmpujeaDKMario es: "+EmpujeaDKMario);
			} else {
				EmpujeaDKMario = DKSpeed*((DKPeso-DKMarioPeso)/100);
				trace("Mario empujado mientras estaba quieto.");
				trace("EmpujeaDKMario: "+EmpujeaDKMario);
			}
			if (EmpujeaDKMario > 0) {
				Player.Moving = Player.Moving-EmpujeaDKMario;
				trace("Moving por ser empujado: "+Player.Moving);
			} else {
				trace("Empuje negativo, no debería ocurrir");
			}
		}
	} else if (Distancia < 0) {
		// DK está a la izquierda de Mario, esto tampoco ocurre por ahora.
	} else {
		// DK está en el mismo lugar que DKMario, tampoco.
	}
}

Resumiendo el código acá me di cuenta de que el empuje no es necesariamente negativo, lo dice el if... Puede ser 0, de hecho al inicio dice que es 0, no lo había visto. Pero en la 2nda salida es negativo. El cálculo es:
EmpujeaDKMario = (DKSpeed+Player.Moving)*((DKPeso-DKMarioPeso)/100);
Supongo que resulta negativo porque Player.Moving es negativo, lo cual como expliqué no sé cómo ocurre en ese momento, parece que a veces se capta una colisión a una distancia menor, pero que yo sepa el tamaño de los dibujos (animados) no varía tanto.

¿Necesitan algo más?

O sea, estaba a Distancia 57.8, hubo colisión, fue empujado a la izquierda, caminó a la derecha intentando oponerse, pero estaba a distancia mayor que antes, y aún así se detectó otra colisión. ¿Acaso el caminar se está aplicando luego de que se dice la distancia, antes de terminar el frame? Digo, puede que la salida esté desordenada, chequearé eso.

A veces cuando enciendo la PC, el monitor muestra imagen y luego nada. Tengo que apagarlo y prenderlo muchas veces para que quede... un poco rojo u oscuro en un costado, pero "bien". Una forma más cómoda es abrir ZSNES, un programa de DOS parece, y hacer alt+tab cada vez que el monitor deja de mostrar imagen. Porque ir a "DOS" y volver a Windows, o viceversa, hace que el monitor se apague o algo así por un momento.

Lo dejo encendido siempre ya con la esperanza de que no dé problemas, pero estar como 5 minútos o no sé cuánto, haciendo alt+tab sin poder hacer mucho más, es como, desastrozo. No puedo mandar a arreglarlo ni conseguir otro.

Pregunto cómo podría, con un programa o test, causar el efecto de "reinicio" de monitor, o apagado y reencendido, como expliqué.
Recuerdo que sucedía con los test de Direct X, posiblemente también con un emulador de Playstation y posiblemente con el cambio de tamaño del escritorio o pantalla en Windows.
Imaginen que no pueden ver. Yo muevo el mouse para un costado, hago clic, apreto Z, sé que se selecciona el ZSNES que está en el escritorio, pongo un juego y empiezo a hacer alt+tab como ¿boludo? hasta que el monitor quede bien.
Me gustaría algo más simple, algo que lo ponga en el monitor, lo abra así con una tecla (puedo ponerle un nombre con X por ejemplo), y que luego tenga el efecto usando sólo 1 tecla.

¿Qué se les ocurre?

Hablando con GPT me dijo algo de crear un programa que se ponga en pantalla completa. Tendría que cerrarse cuando yo le diga. Que se abra con Enter, claro, y en lo posible con Enter también se cierre, pero que el detector de Enter empiece luego de unos segundos para que no se cierre enseguida.
Pero no cualquier pantalla completa sirve. Por ejemplo la de Chrome creo que no sirve, debe ser una que "reinicie" al monitor.

En mi proyecto de juego en Macromedia Flash 5, se le daba una carta al jugador, se le decía cual, y había una pausa hasta que presionara A. Sólo tiene 1 carta.

Quisiera que cuando la carta tiene opciones (causar un efecto u otro), eso se diga al jugador y haya una pausa hasta que presione arriba, o abajo, u otra tecla según cuántas opciones sean.

Parece claro que se puede hacer creando, para cada carta, una variable que marque si la carta tiene opciones o no, y poniendo un if para que dependiendo de eso ponga la pausa básica o la pausa con opciones.

Mi duda es si hay una mejor forma de hacerlo porque no me gusta crear tantas variables ni usar un if cada vez que se obtiene la carta.

Se me ocurre:
- Cuando se obtiene, se busca el valor de una variable llamada Opciones, por ejemplo si se obtiene la carta DKMario se busca una variable llamada DKMarioOpciones.
- Si no tiene valor es que no existe, no tiene opciones, hace la pausa normal. Sino, hace la pausa con opciones.

Eso usa un if pero en vez de crear variables para todas las cartas, crea sólo para las que tienen opciones.

El tema de las pausas también se complica un poco, yo tenía:
// Frame 1: La IA recibe una carta, el humano también.
// F2: Un objeto repite TurnoDeHumano hasta que se presione A.
// F3: Pequeña pausa.
// F4: Turno de la IA.
...ahora debería ser:
// Frame 1: La IA recibe una carta, el humano también.
// F2: Si la carta no tiene opciones, se inserta un objeto que genera la pausa normal. Sino otro que genera la pausa con opciones.
...el resto igual.
Supongo que eso es mejor que crear un frame para la pausa normal y otro para la otra y que vaya para un frame u otro según el caso.

¿Se les ocurre algo mejor?

Uno pregunta porque tiene la esperanza de hallar una respuesta, pero ahora me pregunto para qué preguntar si probablemente no entienda la respuesta:

Lo que entendí es que su "Un solo objeto/clip de pausa" implica hacer ifs a cada rato (120 por segundo creo), así que no me sirve.

Me perdí en lo de diccionario. Quizá está pensando en cosas que aún no pensé.

Ejemplo:
https://www.tiktok.com/@juanmaya_mkt/video/7508633856359107847

https://www.tiktok.com/@juanmaya_mkt/video/7519577801930902792

¿Es que debo estar registrado, es que mi Windows es muy antiguo?

Quisiera escucharlos.

Ese tipo de archivo quiero abrirlo con Paint, pero a veces necesito que sea con Chrome.

Con Paint lo abro haciendo doble clic.

Cuando debo abrirlo con Chrome, hago clic derecho, espero (a veces mucho) a que se muestre el menú, elijo abrir con Chrome.

Es un proceso bastante lento. ¿Algo más rápido?


Tomo fotos a juegos, se guardan como PNG, quiero copiarlas o parte de ellas a Flash, pero si las copio desde Paint quedan mal, pero Paint es lo que más me gusta para borrar partes y copiar, así que debo crear una nueva imagen con el corte, abrirla con Chrome y copiarla de ahí.
Digo eso por si hay alguna mejor alternativa a lo que pido en el título.

https://youtu.be/EM9GATq3QOo?t=1451

¿Real o ficticio?

Como si fuera el puntero del mouse, pero una imagen significativamente más grande y posiblemente con animación, o sea, no creo que pueda ponerse de puntero.

Imaginen que esté andando un videojuego y le meto un gif de lo que quiera. Sé que lo puedo hacer de otros modos, pero tendría que ponerle música y hacer algunas cosas, esto sería cargar el juego, abrir el programa, la imagen, y ya está.

Creo que algunas cosas se repiten, quizá se pueda crear una función HumanoMayLose y otra IAMayLose.

HumanoHP = 20;
HumanoPsn = 0;
IAHP = 20;
IAPsn = 0;
Cartas = ["MarioDK", "DK", "DKJr", "Popeye", "Brutus", "Stanley", "Milk"];
// Lo anterior se usa para causar sus efectos,
// esto es cómo se muestran sus nombres:
ShowerDeCartas = ["Mario de Donkey Kong", "Donkey Kong", "Donkey Kong Junior", "Popeye", "Brutus", "Stanley", "Milk"];
// Frame 1: La IA recibe una carta, el humano también.
// F2: Un objeto repite TurnoDeHumano hasta que se presione A.
// F3: Pequeña pausa.
// F4: Turno de la IA.
// F5: Nada, sólo para mostrar victoria o derrota.
NroDeCartaDeIA = random(Cartas.length);
Mensaje = "Es tu turno";
function HumanoObtieneCarta () {
	NroDeCartaDeHumano = random(Cartas.length);
	Mensaje = Mensaje+"\nHas obtenido a "+ShowerDeCartas[NroDeCartaDeHumano];
}
HumanoObtieneCarta();
// En F2:
function TurnoDeHumano () {
	// Si se presiona A:
	if (Key.isDown(65)) {
		// trace("A presionada");
		// Usa la carta (dando su estadística AT y objetivo a la función):
		// Esto para resumir:
		CartaUsada = Cartas[NroDeCartaDeHumano];
		eval(CartaUsada)(eval(CartaUsada+"AT"), "IA");
	}
}
function FinDelTurnoDeHumano () {
	if (HumanoPsn > 0) {
		HumanoHP = HumanoHP-HumanoPsn;
		Mensaje = Mensaje+"\n¡El veneno te dañó!";
		if (HumanoHP > 0) {
			Mensaje = Mensaje+"\n\nEs el turno del rival";
			// Pequeña pausa, luego turno de IA:
			play();
		} else {
			Mensaje = Mensaje+"\n¡Perdiste!";
			gotoAndStop (5);
		}
	} else {
		Mensaje = Mensaje+"\n\nEs el turno del rival";
		// Pequeña pausa, luego turno de IA:
		play();
	}
}
function FinDelTurnoDeIA () {
	if (IAPsn > 0) {
		IAHP = IAHP-IAPsn;
		Mensaje = Mensaje+"\n¡Rival dañado por veneno!";
		if (IAHP > 0) {
			// Turno de Humano:
			Mensaje = Mensaje+"\n\nEs tu turno";
			HumanoObtieneCarta();
			gotoAndStop (2);
		} else {
			Mensaje = Mensaje+"\n¡Ganaste!";
			gotoAndStop (5);
		}
	} else {
		// Turno de Humano:
		Mensaje = Mensaje+"\n\nEs tu turno";
		HumanoObtieneCarta();
		gotoAndStop (2);
	}
}
// Estadísticas:
MilkAt = 0;
StanleyAt = 0;
DKJrAt = 1;
MarioDKAT = 2;
PopeyeAt = 2;
BrutusAt = 3;
DKAT = 4;
// Efectos:
function TipicoFinDelTurnoDeHumano (ataque) {
	IAHP = IAHP-ataque;
	if (IAHP > 0) {
		FinDelTurnoDeHumano();
	} else {
		Mensaje = Mensaje+"\n¡Ganaste!";
		gotoAndStop (5);
	}
}
function TipicoFinDelTurnoDeIA (ataque) {
	HumanoHP = HumanoHP-ataque;
	if (HumanoHP > 0) {
		FinDelTurnoDeIA();
	} else {
		Mensaje = Mensaje+"\n¡Perdiste!";
		gotoAndStop (5);
	}
}
function MarioDK (ataque, objetivo) {
	if (objetivo == "IA") {
		Mensaje = "¡Tu rival ha sido enjaulado!";
		TipicoFinDelTurnoDeHumano(ataque);
	} else {
		Mensaje = Mensaje+"\n¡DKMario rival te enjauló!";
		TipicoFinDelTurnoDeIA(ataque);
	}
}
function DK (ataque, objetivo) {
	if (objetivo == "IA") {
		Mensaje = "¡Rival dañado!";
		TipicoFinDelTurnoDeHumano(ataque);
	} else {
		Mensaje = Mensaje+"\n¡DK rival te dañó!";
		TipicoFinDelTurnoDeIA(ataque);
	}
}
function DKJr (ataque, objetivo) {
	if (objetivo == "IA") {
		if (IAHP > ataque) {
			HumanoHP = HumanoHP+ataque;
			IAHP = IAHP-ataque;
			Mensaje = "¡Rival dañado y conseguiste "+ataque+"HP!";
			FinDelTurnoDeHumano();
		} else {
			HumanoHP = HumanoHP+IAHP;
			Mensaje = "¡Rival dañado y conseguiste "+IAHP+"HP!";
			IAHP = IAHP-ataque;
			Mensaje = Mensaje+"\n¡Ganaste!";
			gotoAndStop (5);
		}
	} else if (HumanoHP > ataque) {
		IAHP = IAHP+ataque;
		HumanoHP = HumanoHP-ataque;
		Mensaje = Mensaje+"\n¡DKJr rival te dañó y dió "+ataque+"HP al rival!";
		FinDelTurnoDeIA();
	} else {
		IAHP = IAHP+HumanoHP;
		Mensaje = Mensaje+"\n¡DKJr rival te dañó y dió "+HumanoHP+"HP al rival!";
		HumanoHP = HumanoHP-ataque;
		Mensaje = Mensaje+"\n¡Perdiste!";
		gotoAndStop (5);
	}
}
function Popeye (ataque, objetivo) {
	if (objetivo == "IA") {
		Mensaje = "¡Rival dañado y conseguiste 1HP!";
		HumanoHP++;
		TipicoFinDelTurnoDeHumano(ataque);
	} else {
		Mensaje = Mensaje+"\n¡Popeye rival te dañó y dió 1HP al rival!";
		IAHP++;
		TipicoFinDelTurnoDeIA(ataque);
	}
}
function Brutus (ataque, objetivo) {
	if (objetivo == "IA") {
		Mensaje = "¡Rival dañado y perdiste 1HP!";
		IAHP = IAHP-ataque;
		HumanoHP--;
		if (IAHP > 0) {
			if (HumanoHP > 0) {
				FinDelTurnoDeHumano();
			} else {
				Mensaje = Mensaje+"\n¡Perdiste!";
				gotoAndStop (5);
			}
		} else if (HumanoHP > 0) {
			Mensaje = Mensaje+"\n¡Ganaste!";
			gotoAndStop (5);
		} else {
			Mensaje = Mensaje+"\n¡Empate!";
			gotoAndStop (5);
		}
	} else {
		Mensaje = Mensaje+"\n¡Brutus rival te dañó y el rival perdió 1HP!";
		HumanoHP = HumanoHP-ataque;
		IAHP--;
		if (HumanoHP > 0) {
			if (IAHP > 0) {
				FinDelTurnoDeIA();
			} else {
				Mensaje = Mensaje+"\n¡Ganaste!";
				gotoAndStop (5);
			}
		} else if (IAHP > 0) {
			Mensaje = Mensaje+"\n¡Perdiste!";
			gotoAndStop (5);
		} else {
			Mensaje = Mensaje+"\n¡Empate!";
			gotoAndStop (5);
		}
	}
}
function Milk (ataque, objetivo) {
	// ERROR: Esto funciona bien pero está mal,
	// ya que el objetivo está marcando al rival,
	// pero esta carta se aplica al usuario.
	if (objetivo == "IA") {
		HumanoHP++;
		Mensaje = "¡Conseguiste 1 HP!";
		FinDelTurnoDeHumano();
	} else {
		Mensaje = Mensaje+"\n¡Milk rival dió 1HP al rival!";
		IAHP++;
		FinDelTurnoDeIA();
	}
}
function Stanley (ataque, objetivo) {
	Resumen = objetivo+"Psn";
	set(Resumen, eval(Resumen)+1);
	if (objetivo == "IA") {
		Mensaje = "¡Rival envenenado!";
		FinDelTurnoDeHumano();
	} else {
		Mensaje = Mensaje+"\n¡Stanley te envenenó!";
		FinDelTurnoDeIA();
	}
}

Milk: Te da 1HP.

DK: Daña al rival.

Popeye: Daña al rival y te da 1HP.

Brutus: Daña al rival y te daña 1.

DKJr: Daña al rival y te da HP según cuánto dañe (como por ahora su daño es 1, siempre da 1 y no hay necesidad de tanto código, pero eso es por ahora, el código en teoría está bien para cuando cambie).

Stanley: Envenena al rival.

MarioDK: Daña al rival y enjaula (pero aún no se aplica).

De 1:30 a 2 al sur de Montevideo Uruguay, probablemente encima del mar ¿quizá más allá de la superficie del planeta? No lo sé. Hace tiempo, creo que 2 meses, fui a sitios cercanos al mar creyendo que simplemente estaba por ahí, y resultó que estaba más allá, más al sur.

Antes lo que vi era un luz que se encendía desde el oeste, yendo hacia el este, se apagaba, y luego de un timpo, quizá 1 o 2 minutos, se repetía. Como esto:
https://www.youtube.com/watch?v=yj-gPg9xR1w

También se veía una luz muy chica y poco brillante moverse de un lado a otro (este y oeste), es lo que veo ahora, es casi imperceptible... Ahora tengo con qué grabarla pero la calidad es tan mala que no se ve, además mi interés es hablar con ellos (si es que son), y no creo que quieran ser filmados. Intentaré ir más cerca del mar a esa hora, pero me resulta complicado...

Digo esto por si alguien tiene acceso a visión satelital o algo así y quiere mostrarlo. O si alguien es de este país y tiene algo mejor con qué verlo/grabarlo.

Aviso que a esas horas a veces pasa un avión por ahí o al menos en mi línea de visión, y en ese momento las luces no se ven.

En cuanto al título, no es que esté todos los días, pero hace 2 meses creo estuvo todos los días durante 2 o 3 semanas... Y fue a principio de mes como ahora.

Por privado alguien me comentó que tiene interés en el tema de las estafas, le dije que podía abrir un tema sobre cómo protegerse de eso, pero no lo hizo. Y suele haber gente que dice haber sido estafada; algunos cuentan su experiencia para que no le pase a otro, otros más bien tienen interés en encontrar al malechor.

Más recientemente otro me comentó que le interesa el doxeo, que hacerlo por trolear (¿?) o para protegerse, no me queda claro.

Parece que son sombreros negro, pero viendo esto que les puede interesar a todos, aunque pueda ser falso:
https://www.youtube.com/watch?v=HtvVOrEgQqw
pensé en compartirlo y de paso preguntar cómo protegerse, de todo lo malo que pueda ocurrir por usar Internet y esas cosas.

Por mi parte diría:

- Usar antivirus que bloquee malware.
No sé si todos bloquean todo gratis.

- Usar un bloqueador de anuncios.
Ya que las páginas más peligrosas (o más o menos) suelen tener montones de links invisibles, por ejemplo cliqueas la barra de mover la pantalla y se te abre una pestaña o ventana a no se sabe qué página, de nombre rarísimo, o a veces incluso a una descarga que no tiene sentido que aparezca.

- No publicar información personal.
En cierto modo es inevitable, pero no es lo mismo decir en qué ciudad vives, que mostrar una foto en que se pueda saber dónde está tu casa exactamente.
Además tengo entendido que los hackers pueden obtener información del reflejo de ciertos objetos. Del vidrio de una ventana, de un vaso, o algo así. Así es como doxearon a cierta persona, según he leído una vez.

- No dar dinero ni información/fotos que puedan usar para extorsionarte.


- En caso de extorsión...
Bueno, si me están apuntando con un revolver, difícil que piense "No haré caso, porque me podría disparar igual o luego me podría pedir otra cosa y otra, etc", uno tiene la esperanza de que si le haces caso te deje sano, y quizá más de uno aquí ha sobrevivido a una situación así, yo incluído (aunque habría que ver si el arma era real, si estaba cargada, etc), pero en el caso de una extorsión es claro que el malechor querrá quitarte más, o siempre podría tener una copia de lo que quieres ocultar, así que lo recomendable parece ir a la police y posiblemente seguirle el juego hasta atraparlo, aunque aquello que te averguence salga a la luz.

- Si una persona dice querer ayudarte pero que para eso necesita verte en persona...
Podrá haber algún caso en que sí, pero parece mentira. A mí alguien me decía que para enseñarme Programación teníamos que reunirnos en un sitio xP

¿Uds qué agregarían?