Los grandes recursos del minado son, la potencia de cálculo y la energía consumida... Al parecer la energía dices que te sale barata, ahora solo te falta tener potencia de cálculo. De internet, te basta con tener red, no es problema.

No, no es tan fácil. La criptografía es compleja, pero las bases son sencillas.
Esa página web, al y al cabo hace lo mismo que un programa, es decir ejecutar código. Que tengas una interfaz en un programa en tu equipo, no difiere (a efectos dle resultado) en nada a que la interfaz yazca en unaalojada online.

En realidad suele ser así, si consideras la gente que hay en el mundo y la gente que sabe programar y dentro de estos la restricción de los que se dedican a la criptografía.

No existe ningún lenguaje de criptografía. La criptografía es una codificación, luego cualquier lenguaje (de programación) está capacitado para tratar con criptografía.

Como ya te han dicho, se debe investigar un poco sobre el mensaje, el contexto donde aparece y su origen...

En ese caso concreto, se observa que solo tiene letras y hay espacios tal que parece que las palabras siguen conservando su tamaño, luego es fácil intuir que se trata de un cifrado César...

El cifrado César, remplaza cada carácter por otro x posiciones más adelante en el alfabeto.
Rot13, es un caso particular del cifrado César, dado que se usan 26 caracteres, si la 'a' la cifras por la que está 13 letras más adelante, tienes que es la 'n', ... si más tarde cifras de nuevo con Rot13, el resultado cifrado previo, resulta que al cifrar esa 'n' (que venía cifrado de la 'a'), resulta que ahora la que está 13 caracteres más adelante, y por tanto la letra por la que se cifrará ahora la 'n', es la 'a'... por lo que aplicar 2 veces Rot13, es lo mismo que descifrar el mensaje, pués 13*2=26 (el alfabeto (a la hora de cifrarlo) se trata como si fuera circular, tras la 'z' le sigue la 'a', lo que en cálculos matemáticos equivale al resto de una división y que en programación es la archiconocida aritmética modular (operación módulo)).

Si te intresa el tema, y no es meramente una interés puntual hay mucha info, te sugiero iniciarte leyendo la wikipedia y luego si no te aburre, adquiere algún libro sobre el tema...

El fin de semana al final recibí familia en casa y no me dejó tiempo libre, hoy seguramente pueda dedicarle una hora y con otra mañana será suficiente espero...

Los artículos pueden ser editados uno a uno en cualquiera de sus campos, pero también se ha previsto la opción de cambiar el precio a varios a la vez.

Da igual el método que elijas para leerlo, tu tienes que luego que interpretarlo.
Yo sugiero que o bien lo leas entero de una tacada, o línea por línea.
Eso sí, empieza por señalar el tamaño del mismo en 1 o dos lineas:
Ancho = x
Alto = y
ó...
x,y

Considera cada casilla como una unidad... luego en el programa tu tendrás una variable 'factorEscala = n', donde n puede ser un valor que represente el tamaño en píxeles de cada celda, así puede ser 10, 11, 15, 22, 23, 25... es decir independizas el mapa del tamaño que ocupa al dibujarlo. Ese factor podrás cambiarlo desde menú (por ejemplo) o fijarlo al empear el programa en función del tamaño de la ventana.

Considera el mapa rectangular, así sea que luego el mapa tenga una figura irregular, por ejemplo:

30,30
##########=#                 #
#-------#--#
#-------#--#
####-####--#
   #-#--#--#########
   #-####----------#
   #---------------#
####---------------####
#-------#######-------#
####----------#######-#
#--###----###########-#
#----###-##-----------#
#---------#-------#---###
#-------###-------#-----#
###-#####---------#-----#
  #-#------########-----#
  #-#####------#------###
  #-#---#------#------#
  #-#---#------##-#####
  #-###-##-#------#
  #---###---###---############
###-#---#####-#--------------=
#-----#--#------#####---######
##-####----#-####-------#
 #-###########----------#
 #-#-------------########
##-#-------------####
=--###--------------####
###--#-----########----####
     #-#####-------###----#
     #=#             ####=#  #

Nota que ahí las casillas con el carácter '=', señalan una puerta a otra habitación del laberinto. Tras el dibujo del mapa, pondrias
=: 11,1, 6
Que vendria a interpretarse como: la puerta ubicada en la casilla (11,1) comunica con el laberinto numero 6...
Nota como todas las casillas especiales que haya que considerar algo en especial, tras el laberinto (que sabes las lineas que ocupa), las detallas, primero el indicador asociado a la casilla, luego las cordenadas donde se localiza, y luego si proceden otros valores, que pueden significar cosas distintas para cada tipo de casilla.

Tener una plantilla vacía para crear los mapas, facilitará la rapidez en el diseño... empiezas con un cuadrado o rectángulo de un tamaño fijo, que copias y pegas y luego modificas, algo como esto:

30,30
##############################
#----------------------------#
#----------------------------#
#----------------------------#
...
#----------------------------#
#----------------------------#
#----------------------------#
##############################


Esto ya es un poco cosa de tu imaginación...
Podrías por ejemplo tener ficheros del mismo nivel en diferentes carpetas, las carpetas tienen un nombre que señala su nivel 1,2,3... y los ficheros en cada  carpeta, igual, nombres como 1,2,3... .txt.

Sería acorde crear x mapas en una planta, donde cada mapa-laberinto, se comunica con otros por una puerta (esto te permite fraccionar un laberinto gigante en varios más pequeños). Conviene eso sí que aunque el mapa sea irregular ocupen siempre el mismo número de casillas de ancho y alto...
Primero, por supuesto empieza con un solo mapa... y le añades características, a media que te vaya funcionando, vas añadiendo más características, cuando todo funciones bastante bien, entonces creas puertas, escaleras, ascensores... las puertas comunican con otros laberintos (en realidad habitaciones en el mismo laberinto), pero que se representa con su propio mapa y fichero aparte (así tampoco sobrecarga la memoria. Un ejemplo rápido de dibjado de un laberinto compuesto de múltiples laberintos:


Nota que al abandonar una habitación para acceder a otra, esta quese acaba de abandonar, debe guardarse a fichero pero ahora en vez de un txt, le das por ejemplo una extensión .temp, si vuelves a ella verificas si existe el fichero (por ejemplo), 6.temp, si lo hay se abre ese (que indica que tiene el estado de como se dejó la última vez que se visitó), si no se localiza, es que nunca se entró en él, en tal caso abres el 6.txt... Cuandos se termine la partida, se eliminan todos los temp.

Los niveles, pueden ser creados por dificultad. La dificultad en una parte de las más complejas en los juegos (a la hora de programar)... pero en un laberinto pueden hacerse facilmente haciendo casillas ocultas...
Casillas ocultas, son casillas que externamente (visiblemente) su imagen es la misma que una pared o una vacía, pero al pasar sobre ella se activa y se dibuja de su verdadero valor (el jugador debe intentar acceder a ella, para que se revele dicha casilla).
Por ejemplo si esto es una pared #######, podría poner una casilla libre pero que se deja oculta, por ejemplo así: ####@###,
'@' señalaría que es una casilla libre (igual que '-' pero que se dibuja como una pared y una vez pisada, ya se dibuja como libre, es decir en tu array (después de intentar acceder a ella) cambias el valor de la casilla de '@' a '-', así posteriores veces que se deba dibujar, se dibuja como libre... el mismo procedimiento puede emplearse, al revés una casilla que parece libre, que en realidad sea una pared... el ugador no podrá avanzar y ahí está la salida, deberá descubrir como, y esa casilla luego se dibuja como pared (al intentar acceder a ella)...

Puedes hacer creer al jugador que los niveles se encuentran a diferentes alturas, cuando suba niveles, son más complicados de resolver, o les cuesta más tiempo, pero puedes asi ocultar habitaciones... en los niveles más simples.
Eso sí para darle a entender al jugador los diferentes tipos de casillas, crea un nivel donde en cada habitación dle laberinto, le enseñas una o dos casillas distintas, para que se familiarice con lo que implica, incluso en ese nivel, podría crear casillas 'info' 'i', que cuando se pise, debajo muestre un texto de ayuda algo como: "Cuando veas una llave recógela, te servirá para abrir alguna puerta cerrada."

Y en el mensaje previo se me olvidó indicarte, hay un muy buen libro que trata este tipo de juegos, aunque es viejo, aunque el código que trae es espagueti (sin apenas estructura y repleto de goto y gosub (está en un Basic primitivo d elos spectrum Sinclair, sin embargo sigue vigente en cuanto a la estrategia para realizar ciertos tipos de juegos, eso sí está en inglés, aunque también sacaron la vrsión en español (yo la que tengo está en inglés): "Spectrum Adventures"

Básicamente sí...

Si, te pongo un mapa inicial de ejemplo y una captura del juego...

En el mapa en vez de cifras, se han usado letras... no tiene importancia, en tanto uno interprete correctamente el significado de cada una. Usar valores de byte, es adecuado si la cantidad de casillas disitntas es elevada, si solo hay 2 o 3 decenas a lo sumo, las letras y números y poco más debería valer igual de bien.

ancho= 27
alto= 17
###########################
#----##--#D--#-##---2---U##
#-2---------2#-#-2----#-2##
##-----U-----#-----##-#2###
##############---------2###
#----------2#---U--##---2##
#2----------#-#---#-------#
#2-----#------#-----------#
#2---#----U2--------#-----#
#----#----2--------###2---#
#--------#------------22#-#
#2-----------U2--------##-#
#2#-#-----------##--------#
#-#-------------#------#--#
#-----2-----2-###2----##22#
##S-----###-------##-----##
###########################


El juego tiene por objeto partir de una casilla dada y llegar a la meta. Se mueve una 'bola' (por simplicidad en vez de dibujar un monigote con forma humana). La principal particularidad de este juego, es que nos e mueve una casilla por vez, una vez 'empujada' en una dirección avanza hasta chocar con un obstáculo que le impide seguir, lo que dificulta el camino a seguir para llegar a la meta.

Fácilmente se intuye que las casillas con el carácter # son paredes y las casillas con el carácter '-' son espacios libres (puede haber casillas ocultas, tanto en paredes como en espacios libres).
El carácter 'S', marca la posición inicial (salida) del jugador.
El carácter '2' marca esas estrellas que dan la puntuación, por cada una recogido (cuandose visita la casilla, se muta en una de espacio libre, esto es si mapa(x,y)= 2 luego mapa(x,y)= #
El carácter 'D' es la meta, como se ve está encerrada, luego tiene que haber alguna forma de entrar...
El carácter 'U' es una especie de túnel, los naranjas, por ejemplo entran por uno y salen por otro (están conectados dos entre sí, esto se indica en el mapa después del tablero (dibujado más arriba) algo como:
U: 16,5 = 10,8
U: 10,8 = 16,5
Que quiere decir, el 'túnel de la casilla X=5,y=16' mueve la bola al túnel en la casilla 10,8
El otro devuelve al mismo sitio, aunque no es obligatorio, moverá siempre adónde se indique.
Hay 2 parámetros adicionales más que no he puesto que indican desde qué orietación admite la 'entrada al túnel' y en qué direcciones permite la salida por el otro (como hay 4 orientaciones, N,S.E.O se representan con un valor: 1+2+4+8, es decir si la entrada vale 9, quiere decir que admite entrada por Norte y Oeste (8+1).
Como se vé ciertas casillas al llegar a ellas requieren una acción. lo adecuado es predefinir las acciones y asociarlas a cada tipo de casilla distinta.
Si requiren más datos adicionales, tras el 'dibujo del mapa', se pone el tipo de casilla especial, sus cordenadas y los parámetros que la misma precise.

Lo ideal es poder dibujar mapas aleatoriamente, pero iniciamente debes dibujarlos a mano, para ir probando el funcionamiento de las características que vas añadiendo.

Aquí una captura poco después del comienzo del juego (el mapa es de 17x27 casillas):
La casilla 'verde' representa la bola que maneja el jugador...



Empieza por dibujar una mapa en un fichero de texto, similar al que te he puesto, de momento solo casillas libres y paredes.... luego programa la lectura del fichero a un array (precede el mapa de su tamaño, para antes de crear el array del tamaño adecuado) una vez leído dibújalo...
Luego añade un símbolo para el jugador, bibújalo, haz que se mueva sin rebasar las paredes...
Después añade más características y finalmente dale las reglas al juego. Define un objetivo y las reglas de movimiento del jugador y de cada casilla.

Seguramente tengas ocupadas todas las líneas de interrupción dedicadas a los puertos USB-2.
Al apagar se desconectan las señales adjudicadas y al iniciarlo de nuevo las reasigna a los dispositivos que localice, si lay libres podrá s adjudicarlo, si no, no.

Hola no es necesario escribir mensajes por privado para esto. En todo caso sí para pasar datos.

Y no, lo lamento no tengo Discord.
No es necesario que expongas todo el proyecto, solo las dudas que te vayan surgiendo o lo problemas que no sepas como resolver.

Hoy saqué un rato y pude dejar casi terminado, la parte que opera con el almacén y los artículos.

A ver si mañana o pasado saco otro ratito y hago la parte equivalente para las ofertas...

Sendas partes, requrirán de un fichero adicional que mantiene sus propios registros, también implica hacer cambios a alguna ventana. La ventana de compras, hasta ahora introducía artículos manualmente, luego tendrán que elegirse de un combo que contendrá todos los artículos del almacén.

Los cambios a posteriori, como ya te he dicho en varias ocasiones, fuerzan a modificar parte de lo ya hecho. Te recomiendo que consideres en adelante hacer un análisis de requisitos previo a escribir una sola línea de código, poder así diseñar como ha de ser la aplicación y que pártes se encargan de qué trabajos, so pena de estar modificandocontínuamente paertes que hacen un trabajo que en realidad pertenece a otra parte, cuando esa parte se integra, por que no se hizo en su momento.

Como siempre no está probado...


Aquí una captura (del IDE), de la ventana de edición de artículos...

Peor aún, el reporte del enlcace que envía MCKSys Argentina, revela que el primer envío y detección de dicho virus data de: First Submission 2022-02-17 18:01:31 UTC

Es decir que antes de tú dar el enlace ese virus no constaba.

Luego o lo has creado tú o lo has sacado de una 'máquina del tiempo' (la fecha dice datar de 1992, pero es algo fácilemtne falsificable), y en este caso para qué resucitar un software tan viejo?. Estimando ciertos los datos que arroja **Aincrad** que se trata del juego Valorant, que según wikipedia salió al mercado en 2020, no cuadra con la fecha de 1992, con lo que la 'aguja' te señala aún más a tí como el posible creador del virus.

Si simplemente te lo has bajado de alguna parte está recién salido del horno y ... entonces está claro que te has infectado. Toma las acciones necesarias.

Antes de mover el jugador, necesitas una función 'SiPuedeMoverseA(x,y)' que devuelva un buleano. Si devuelve TRUE, es entonces cuando lo mueves, no antes. Y una vez movido, no cabe preguntar de nuevo hasta que vuelva a moverse.

supongamos que el jugador está en la casilla 3,7 y quiere avanzar 1 a la derecha:
+1, -1 y 0, para el eje vertical u horizontal es algo que obtienes por las teclas pulsadas.

Lógicamente +1, -1 , 0 se pasan en variables x,y

Por su parte el puede moverse, no parece tener sentido que pases una 'pared' salvo que sepas que esa pared está ahí... localizar una pared, no deja de ser algo costoso.

Los incrementos  +10, -10... he de suponer que son valores unitarios, es decir que no pueden ubicarse en valores 5, 13, etc, si no siempre en múltiplos de 10.

Si tienes un laberinto, lo mejor no es tener 'paredes', si no un array de X*Y de ancho y alto, el laberinto lo presentas cada casilla con valores numéricos, por ejemplo una casilla libre con valor 0, una pared con valor 255, una puerta abierta con valor 1, cerrada con valor 254 (de existir escaleras; escaleras arriba con valor 249, abajo con valor 248) , objetos recogibles por el jugador con otros valores... Reserva los valores 250 a 254 para otros objetos que aunque no sean paredes no pueden el jugador moverse ahí (imagina por ejemplo un agujero en el suelo rodeado de una barandilla) .
Si hay muchos objetos accesibles, casi tantos como inaccesibles, considera usar valores pares para los accesible e impares para los no accesibles (como puerta abierta y cerrada, etc...).

Entonces ahora tu función simplemente trata de verificar si la casilla a la que el jugador quiere acceder es accesible o no.


Si diseñas adecuadamente los valores, para que las casillas accesible queden juntos y los inaccesibles juntos, se simplifica la operatoria, además si dejas los valores más extremos los que simplemente devuelven true y false y nada más y el resto más internamente para los que además hay que hacer alguna acción, por ejemplo si sube escaleras (7-10-15 peldanos (pasos), muestras el mapa de la planta a la que se accede (guardas el mapa del tablero actual y cargas el de dicha planta), o si se coge un objeto mostrar un mensaje (el jugador tiene la llave de la puerta 3, por ejemplo), etc...

Los laberintos se realizan básicamente como te he explicado, cada casilla está representada en un array bidimensional, con un valor que señala el tipo de casilla. Una enumeración señala los diferentes tipos de casillas, que además te sirven para dibujar el mapa acorde al valor de la casilla.