Mensajes

Es una opción más, no una panacea para los videojuegos.

En vez de basar todo un juego en la realidad virtual, podrían simplemente limitarlo a determinados momentos o escenas de un juego y ampliarlo en la medida que sientan que los jugadores lo apoyan.

Exponer un cambio radical que no ha sido demandado, sobre todo entraña ese riesgo económico del desembolso y no verlo de vuelta.

Está más que demostrado que si tomas un grupo de 'gamers' exigentes y les pones de repente unos juegos de arcade de los 80, redescubren el placer de jugar sin tantas frivolidades a menudo superfluas.

Si los negocios de videojuegos no saben encontrar el punto exacto entre lo que ofrecen y la jugabilidad que los jugadores esperan, es fácil perder 'la batalla'.
Por muy 'gamer' que se sea, el límite del gamer suele venir impuesto por su economía, así que apostar a que dichos gamers vayan a adquirir juegos novedosos enormemente caros (a menudos seguido por adquisiciones hardware para poder jugarlos), donde el sobrecosto es por una tecnología no demandada, está abocada al fracaso.

...deben encontrar un punto medio donde el costo del juego no sea disimilar a lo previo y donde la inmersión de la tecnología aparezca, a precio asequible para ambas partes. ...y si resulta bien, ir introduciéndolo poco a poco. Es decir generar clientela que demanda un producto en vez generar un acopio de producto para el que no hay suficiente clientela.

Por qué incandescentes?. Aunque no estén mucho tiempo encendidas, a lo largo del año, suman muchas horas. tira por bombillas leds. Hay una gran variedad en cuanto a luminosidad, si es lo que buscas.

Y siendo zonas de paso, a falta de saber la exactitud de como quieras usarlas, considera la posibilidad de usar un sensor de movimiento para activarlas.

Es que esto no llovió en un día.

Cada uno de los lenguajes se realizó (y se continúa) pensando en solucionar determinados problemas que aparecían en otros o bien a situaciones a las que no daban solución.

Hay varios hitos en la Historia:
- La teoría de conjuntos con Cantor.
- Charles Babbage y su máquina analítica.
- El primer programa de la Historia se concede a Augusta Ada Byron (hija de Lord Byron), al sugerir y programar mejoras en la máquina de Babbage.
- El álgebra de Boole como una clarificación de la teoría de conjuntos que supone la lógica proposicional.
- Las mejoras en aritmética introducidas por Dedekind.
- La arquitectura von Neumann de John Von Neuman en una dosis de genialidad, traza lo que es el comienzo de los ordenadores físicos (palpables), más bien el cálculo a través de 'máquinas' como se concebía por entonces.
- El lingüista, Noam Chomsky definió una jerarquía de los lenguajes bien fundamentado, no caprichosamente.
- Claude Shannon, definió la 'teoría de la información'.
- Fano y posteriormente Huffman, aplicaron dicho concepto para algoritmos, como la compresión en fechas que aún no había ordenadores como los vemos hoy.
- El primer chip integrado (que dejaba atrás las válvulas de vacío). Tengo por ahí revistas de mediados de los 50, de radio y Tv. que narraban las noticias como hoy escuchamos las noticias de la Nasa en cualquier revista de divulgación científica, o igual que se recogían las noticias de la llegada a la Luna.
- Hacia finales de los 50 y comienzos de los 60, se podía asumir que "cada maestrillo tiene su librillo", entonces a alguien se le ocurre reunir, compartir y divulgar todo ese conocimiento que está retenido de forma exclusiva en unos pocos, se crean y patrocinan grupos, congresos y series de divulgación centrada en la materia.
- El concepto de 'programa compiladao'.
- Con John Backus y su propuesta para Algol, y después a Peter Naur surgió el BNF, que permitió doblegar la descripción exahustiva de la sintaxis de los lenguajes hasta entonces, nadie podía alegar conocer completamente ningún lenguaje. algol fue el primero en verse como un lenguaje basado en las especificaciones. Hasta entonces, era puro arte sujeto a errores sin posibilidad de ser exahustivos.
- Con las críticas de Dijkstra sobre el uso del 'Goto' puede afrimarse que nace la programación estructurada.
- ADA tuvo el mérito de unificar criterios, con lo que surgieron los estándares, para no rehacer la rueda. El Departamente de Defensa de USA usaba por aquel entonces alrededor de 500 lenguajes distintos, por supuesto totalmente incompatibles entre sí, que suponían un gasto económico. Podría casi afirmarse que se creaba (o actualizaba) un nuevo lenguaje para cada contrato... ADA vino a solucionar esa infinita diversidad.
- Con John McCarthy, surge Lisp y la inteligencia artificial.
- Kemeny y Kurtz, crearon en 1964 el BASIC... el lenguaje mas cercano al natural aunque muy limitado en funcionalidad, que vino a demostrar que la complejidad puede ser absorbida. Pascal y C son 4 y 8 años posteriores al BASIC, curiosamente.
- Niklaus Wirth con Pascal, asienta en las universidades el estudio de la informática. Hasta entonces los lenguajes eran demasiado complejos, la gente 'común' reuía de ellos.
...
- La programación orientada a objetos, ya estaba muy presente desde prácticamente los 70, pero era conceptual, no es hasta la primera concrección de Bertrand Meyer (quien define y especifica Eiffel), cuando se consagra como tal.

Ni mucho menos los dados en la lista, son todos, solo los que me han venido a la memoria a bote pronto y acortada. Dennis (no Daniel) Ritchie?. Probablemente no lo incluyera como significativo.
En fin, como decía no fue un diluvio de un día, si no muchas lluvias a lo largo de muchos años...


Explicar cada paso en detalle requiere un libro bien gordo, pero 'tirando del hilo' podrás ampliar. Así que te he buscado algunos enlaces:

Historic Documents in Computer Science:
http://web.eah-jena.de/~kleine/history/

The History of Language Processor Technology in IBM:
https://pdfs.semanticscholar.org/20fb/5f3fe267f8df829da85f160868f0dc314abe.pdf

Desde wikipedia:
https://en.wikipedia.org/wiki/History_of_programming_languages

[¿Que está pasando?]

...
Me acaba de llegar la luz ultravioleta, es esta:

Bien, acabo de montarla en un portalámparas y me he dispuesto a comprobar los sellos del tabaco, y unos billetes que tenía en la cartera.
Tengo un billete de 50, 20 y 5 euros, e mirado con esta bombilla, y no se ven las marcas de agua!!!!
Por supuesto los sellos del tabaco, no se ven las marcas de agua!!!
Entonces estoy pensando que tal vez esta bombilla no funcione bien???
Pero como es posible si es ultravioleta y dice que es para detectar billetes falsos???

¿Que está pasando?
...

Acude a la policía (incluso a un banco), con la lamparita y algunos de esos billetes 'que no se leen' y algún paquete de tabaco.
Ellos suelen saber bien como se aplica (los del banco lo saben bien, la policía según quien) y pídeles que te expliquen o bien que verifiquen ellos mismos si son falsos.

Nota, sin embargo que la luz ultravioleta, si se aplica en un sitio muy luminoso, no se podrá discernir con claridad, requiere aplicaro en un sitio como mínimo en sombra o penumbra. Cuanta más oscuridad mejor se percibe... 

[expresion = valor operador valor|operador valor]

Se te está pidiendo un reconocedor de lenguaje, un autómata.
Tienes que empezar por definir correctamente el problema.
La mejor manera es hacerlo en BNF...

expresion = valor operador valor|operador valor  // operación binaria y monaria
valor = [signo] numero [variable]
expresion = monomio|numero [operador expresion]    // uno y/o más numeros o monomios
monomio = [signo] numero [potencia]
potencia = opPotencia numero
signo = "+"|"-"     // un signo también es un operador como se verá más abajo.
numero = digito numero   // uno o más dítitos.
digito = "0"|"1"|"2"|"3"|"4"|"5"|"6"|"7"|"8"|"9"
operador = "+"|"-"|"*"|"/"   // Se puede añadir los operadores que se quiera.
opPotencia = "^"
variable = "a"|"b"|"c"| ... |"x"|"y"|"z"  // OJO: Variable es una sola letra minúscula (deducido a partir de la expresión de ejemplo)


Desde ahí se puede pasar ya a codificarlo, pero se requiere cierta experiencia para poder hacerlo clara y eficientemente... para aprender es mejor interponer el propio autómata sus estados, así que es ése el pseudocódigo que te pongdré más abajo...

Ahora se trata de generar una tabla con los estados de transición conforme a las reglas previas:
Una tabla de estados es un cuadro donde se colocan todas las variables en juego (pueden agruparse caso de 0-9, a-z cuando para ellos se dan idénticas condiciones sin excepción), esto es, el estado actual, los estados previos y se rellena con el estado de transición.

En vertical el token actualmente siendo leído, en horizontal el token previo (no hay problema en intercambiarlo, siempre que quede claro).
La tabla recoge a que estado avanza desde el token previo al token actual...

 
previo| signo | 0-9 | a-z | separador | operador | potencia |
----------------------------------------------------------------
actual|---------------------------------------------------------
----------------------------------------------------------------
signo |   6?  |  1  |  5  |    -      |    2     |    e     |
----------------------------------------------------------------
  0-9 |   6   |  1  |  e  |    -      |    2     |    1     |
----------------------------------------------------------------
  a-z |   6   |  5  |  e  |    -      |    2     |    e     |
----------------------------------------------------------------
sepa. |   x   |  x  |  x  |    -      |    x     |    e     |
----------------------------------------------------------------
oper. |   e   |  1  |  2  |    -      |    e     |    e     |
----------------------------------------------------------------
opPow |   e   |  e  |  7  |    -      |    e     |    e     |
----------------------------------------------------------------
otros |   e   |  e  |  e  |    -      |    e     |    e     |
----------------------------------------------------------------


La tabla de estados se lee como sigue:
- Un valor 'e' significa un estado de error. Si se da debe abortarse y darse por fallida la validación de la expresión.
- Un valor 'x' significa que es un estado superfluo, no se hace nada (debe ignorarse, esto supone devolver a token su valor previo) y seguir leyendo.
- Un valor '-' significa que dicho estado no se dará, porque cuando sucedió, es transitorio en el mismo ciclo al estado previo.
- Un valor '6?' significa un estado 6, pero que debe hacerse una comprobación posterior (in situ).
- El resto de valores indican el estado al que se cambia, desde el token actual y sabiendo el token previo.
El estado final de la validación debe ser 1 ó 5. Estos valores señalan que se ha validado correctamente, si al llegar al final de la expresión se tiene un estado 2 ó 6, la expresión hasta ese momento es correcta, pero incompleta, por tanto se da como errónea.

Como hablamos de tokens... conviene crear una enumeración y un array que 'tokenice' cada carácter en nuestro 'lenguaje'
Antes de nada, pues, establecemos valores para reconocerlos.

Código [Seleccionar] Expandir

enumeracion TipoToken
     //TOKEN_ESCAPE = -2
     //TOKEN_ERROR = -1
     TOKEN_DESCONOCIDO = 0
     TOKEN_DIGITO = 1
     TOKEN_OPERADOR = 2
     TOKEN_SIGNO = 6  // es también un operador.
     TOKEN_SEPARADOR = 3
     TOKEN_VARIABLE = 5
      TOKEN_OPPOTENCIA = 7
fin enumeracion

TipoToken Tokens(0 a 255)

funcion Inicializar
    entero k

    // Digitos: 0-9
    bucle para k desde 48 hasta 57  
         Tokens(k) = TOKEN_DIGITO
    siguiente

   // Variables: a-z
   bucle para k desde 97 hasta 122
         Tokens(k) = TOKEN_VARIABLE
    siguiente

   // Operadores (y signo):
    // la función 'ASCII', es una forma de dejar claro el contenido asociado más que evitarse poner el valor ascii asociado a cada uno de ellos.
   Tokens(ascii("+")) = TOKEN_SIGNO
   Tokens(ascii("-")) = TOKEN_SIGNO
   Tokens(ascii("*")) = TOKEN_OPERADOR
   Tokens(ascii("/")) = TOKEN_OPERADOR

    // Operador Potencia:
    Tokens(ascii("^")) = TOKEN_OPPOTENCIA   

   // Separadores:  'espacio' (pués es solo un jemeplo, que puedes ampliar)
   Tokens(ascii(" ")) = TOKEN_SEPARADOR
fin funcion



Inicialmente el 'estado previo' debe ponerse en 1.
Se empieza recorriendo carácter a carácter en un bucle... se obtiene un token y debe considerarse el estado previo, para asignar el estado conforme a la tabla de estados, decrita más arriba.

Código [Seleccionar] Expandir


// NOTA: considera un 'break;' con cada caso... (tramitándolo como 'C').
Buleano = Funcion ParseExpresion(array bytes Expresion())
   entero Index, Size, signos, IxImprime
   TipoToken token, prevToken
   
   index = 0
   size = Expresion.Length
   IxImprime = 0
   prevToken = 1

   Hacer mientras (index < Size)        
       token = Tokens(Expresion(Index))

       Seleccionar caso de Token
           caso TOKEN_DIGITO
               Seleccionar caso de  prevToken
                   caso TOKEN_SIGNO
                       Estado = 6
                   caso TOKEN_DIGITO
                       Estado = 1  
                   caso TOKEN_VARIABLE
                       Estado = 0  //Error...   las digitos nunca aparecen tras una variable:  5+'b2'35-6
                       Salir del bucle    
                   caso TOKEN_OPERADOR
                       Estado = 2  
                    caso TOKEN_OPPOTENCIA
                        Estado = 1
               Fin caso

           caso TOKEN_VARIABLE
               Seleccionar caso de  prevToken
                  caso TOKEN_SIGNO
                       Estado = 6
                   caso TOKEN_DIGITO
                       Estado = 5    
                   caso TOKEN_VARIABLE
                       Estado = 0   //Error...  las variables solo son de 1 caracter (no se toleran identificadores más largos): 5+'bh'-6
                       Salir del bucle
                   caso TOKEN_OPERADOR
                       Estado = 2
                    caso TOKEN_OPPOTENCIA
                        Estado = 0   //Error...  detras del oppotencia debe aparecer digitos, solamente: 5x'^z'-6
                        Salir del bucle   
               Fin caso

           caso TOKEN_OPERADOR   // Signo, aunque conta como operador tiene valor 6, se trata en signo.                
               Seleccionar caso de  prevToken
                  caso TOKEN_SIGNO
                       Estado = 0   //Error...  detrás de un signo no puede aparecer ningún operador:  5'-*'3
                       Salir del bucle  
                   caso TOKEN_DIGITO
                       Estado = 1    
                   caso TOKEN_VARIABLE
                       Estado = 2  
                   caso TOKEN_OPERADOR
                       Estado = 0   //Error...  detrás de un operador no puede aparecer otro operador: 5'/*'3
                       Salir del bucle
                    caso TOKEN_OPPOTENCIA
                        Estado = 0   //Error...  detras del oppotencia debe aparecer digitos, solamente: 5x'^z'-6
                        Salir del bucle  
               Fin caso

           caso TOKEN_SIGNO
               Seleccionar caso de  prevToken
                  caso TOKEN_SIGNO                    
                       si (signos < 2)
                           Estado = 6
                           signos +=1
                       sino
                           Estado = 0  // Error...   No puede haber más de 2 signos seguidos:  5'+-2'; 5'-+'4
                       fin si
                   caso TOKEN_DIGITO
                       Estado = 1  
                   caso TOKEN_VARIABLE
                       Estado = 5
                   caso TOKEN_OPERADOR
                       signos =-1
                       Estado = 2
                    caso TOKEN_OPPOTENCIA
                        Estado = 0   //Error...  detras del oppotencia debe aparecer digitos, solamente: 5x'^z'-6
                        Salir del bucle  
               Fin caso

            caso TOKEN_OPPOTENCIA
                Seleccionar caso de  prevToken
                   caso TOKEN_VARIABLE
                        Estado = 7
                   resto casos                         
                        Estado = 0   //Error...  antes del oppotencia solo puede aparecer una variable (como en: 5'x^'2)
                        Salir del bucle   
                Fin caso                       

           caso TOKEN_SEPARADOR
               token =  prevToken

           caso TOKEN_DESCONOCIDO
               Estado = 0  // 'e' el valor asociado al error.
               Salir del bucle
       Fin caso
       
       Si (token <> TOKEN_SIGNO)
           Si (signos = -1)
               signos =1
           Sino
               signos = 0
           Fin si
       fin si

       // Imprimir aquí el valor. si por monomio es la 'produccion/regla "valor" (descrita más arriba),
       // debes ir concatenando tokens, y cuando TokenPrevio = 1 ó 5 y token = 2 ó 6, se imprime, sino se concatena...
       // algo más eficiente que concatenar es recordar el index previo, y al imprimir usarlo desde ahí hasta el actual (incluído).
       Si ((prevToken = 1) o (prevToken =5))
           Si ((Token = 2) o (Token = 6))
               imprimir desde Entrada(IxImprime) hasta Entrada(Index)
               IxImprime = (Index +1)
           fin si
       fin si      

       prevToken = token
       index +=1
   Repetir

   Si ((Estado = 1) o (estado = 5))
       Devolver  TRUE
   Sino
       Devolver FALSE
   Fin si
fin funcion


p.d.: Intercambiado valores en token= signo y previo= digito con el opuesto token= digito y previo= signo.

Reasignando otros valores de estado, se puede dejar más claro...
0 = desconocido, 1 = separador, 2 = operador, 3 = signo, 4 = digito, 5 = variable
Prevtoken conviene que se establezca inicialmente siempre al estado asignado a 'digito', para que pase a un estado válido si el primer carácter lo es.

NOTA: Al ver que luego has puesto otra expresión he recalado en la previa y he visto que no me percaté de que usas expresiones algebraicas... El pseudocódigo como estaba resolvía acertadamente las expresiones aritméticas, pero no las algebraicas... como esa que pusiste al inicio: "+3x^2-2x^1+9x^5-4+5x^3+1".
Es solo añadir alguna regla más y un estado distinto para el operador de potencia y luego añadir en la función 'ParseExpresion', los casos para dicho nuevo estado. Hago los cambios para que quede correctamente.
También resolverá correctamente un término suelto como 3x^0+5 si se pone como 3x+5

Pués sí...

Yo aún conservo un Vic-20 (una versión anterior al Commodore-64) y un ZX Spectrum, de los primeros, que tenían en teclado de goma. Aunque este lo tengo averiado. Hace 8-12 años quise buscar alguno viejo por intenet para arreglarlo, pero incluso solo para piezas estaban carísimos...

['Cuál es la última contraseña que recuerdas?']

Gmail, ofrece varios modos de recuperación de cuenta...

A veces que ha cambiado la contraseña de la cuenta y he olvidado anotarla y no he vuelto a entrar a ella durante cierto tiempo, acabo por olvidar dicha nueva contraseña, en tales casos suelo escoger el método: 'Cuál es la última contraseña que recuerdas?', e inmediatamente pongo la que tenía antes o incluso alguna anterior, pués las suelo anotar en casa... La ventaja de este sistema, es que puede ser muy probable que uno sí que recuerde alguna contraseña previa por que la mantuvo mucho tiempo y aún la recuerda o tiene todavía alguna anotada...

Una vez que recupere SU cuenta de email de Gmail, que solicite de nuevo, el ingreso a la plataforma de interés que dispondrá (se supone) de la verificación exigida en su bandeja del correo (típicamente las verificaciones caducan en un timpo limitado, es decir solo tendrán validez durante ciertas horas, rara vez mayor de las 24 que dura un día).

De todos modos, en el teléfono móvil, sueles tener la cuenta de correo permanentemente abierta... con lo que no precisas meter cada vez la misma. el caso suee darse cuando intentas acceder desde el navegador sea del PC o del tf. y borraste las cookies.

Todavía es muy propable que la plataforma del juego en cuestióndisponga de más opciones como quizás enviar un SMS al teléfono...

La estatua de la Libertad, acaba de perder un brazo.

...Trump la ha arrancado para metérsela por el @N0 a sus ciudadanos...

Intel lleva ya bastante tiempo estancado en los mismos namómetros.

Equipos con gran consumo, no son precisamente la solución. Así que los Ghz no los van a salvar... deben dar el salto de escala en la integración, pero Joule se ha impuesto como barrera insalvable.

Las siempre polémicas decisiones de Mocosoft...
Una parte de los usuarios 'morirá' con dicha decisión.

Creo que al final se equivocan entre dejar de actualizar y no permitir la coexistencia en futuros equipos.

La informática se fabricó coja y seguirá coja... debería ser posible en cualquier procesador de hoy día, poder instalar (si uno quisiera), cualquier sistema operativo anterior. Por ejemplo: algo tan vetusto como un windows 95... con exactamente las restricciones que tenía el propio sistema operativo. Después de todo, todos los requisitos que exigía un viejo S.O. lo cumple cualquier equipo de hoy día. Pero en fin, las empresas de software, consideran que les favorece forzar actualizaciones incluso obviando que alguien tenga ya en su casa un flamante win-10, pero aparte quiera mantener un viejo equipo.