Skip Navigation

User banner
Posts
5
Comments
782
Joined
2 yr. ago

  • I've seen people good at typing on a touch screen and they do so, astonishingly well. I myself, am not able to type on touch well enough and just use swype instead (despite the frustration).

  • Swype typing can get pretty fast tbh. But that greatly depends upon the software.
    Despite the hate it got, Windows Phone's default keyboard had a far superior swype experience as compared to Android and iOS. Probably because they didn't try to inculcate all user words into their dictionary and used the sentence structure as a reference to rank the predicted words.

    Had this one been OSS, it would have been a great service. But now it has been scrapped along with the rest of Windows Phone. One of the reasons why I hate to think of what would happen to any high effort thing I make in a company.

  • with a smartphone in your hand

    They are probably better at touch^[as in touchscreen :P] typing.

  • Well guess what? That was an e-book and you only get to read once.

  • I just re-read my comment and realised I was not clear enough.
    You bundle the text and the AI-TTS. Not the AI text generator.

  • So it's summer season. Was it supposed to be a bit to the North, or a bit to the south? Or a lot to the north? until when is it considered summer anyway? October? November? It's still pretty hot out there.

    The last time that happened, I was trying to hurry back home, before the rain started pouring. And guess what? I couldn't see the sun.

  • RIP

    Jump
  • You'll need an extra feat to add the time delayed parameter selection metamagic.
    Or you could just imbue a nino-magatama with it and give it to a fellow wizard to use it on you.

  • A really good place would be background banter. Greatly reducing the amount of extra dialogues the devs will have to think of.

    1. Give the AI a proper scenario, with some Game lore based context, applicable to each background character.
    2. Make them talk to each other for around 5-10 rounds of conversation.
    3. Read them, just to make sure nothing seems out of place.
    4. Bundle them with TTS for each character sound type.

    Sure, you'll have to make a TTS package for each voice, but at the same time, that can be licensed directly by the VA to the game studio, on a per-title basis and they too, can then get more $$$ for less work.

  • I am starting to understand why stealth games portray guards as easily head-flippable.
    It's because they already have it halfway there for the player.

  • When Google Navigation tells you to "head North-East".

    I am a fool who bought an Android phone without a magnetic compass.

  • Bread

    Jump
  • I tried the rubber band. I tried the clip. Neither work.
    Only the fridge does. And that works well enough. I either tuck it, or I take it all out and keep it on a tray. Open. If I keep it for long enough to make it dehydrated, it's my fault.

  • OIC. Good to know in case I ever have to work on some old CentOS 5 box lying around ever again.
    It also looks kinda proper, using that instead of the @, so when making shell scripts, I might want to prefer this.

  • And more de-obf:

     C
        
    #include <stdio.h>
    
    const char addarr1[]
        = { 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40,
            0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x0,
            0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,  0x40,
            0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,  0x40,
            0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
            0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x0,  0x40, 0x40, 0x0,  0x40,
            0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40,
            0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x0,  0x0,
            0x40, 0x0,  0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40, 0x40, 0x40, 0x40,
            0x0,  0x0,  0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40,
            0x0,  0x40, 0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x40, 0x0,
            0x40, 0x40, 0x40, 0x40, 0x0,  0x40, 0x0,  0x40, 0x40, 0x40, 0x40, 0x0,
            0x40, 0x40, 0x40, 0x0,  0x0,  0x0,  0x0,  0x0 };
    
    const char addarr2[]
        = { 0x9,  0x26, 0x20, 0x39, 0x2f, 0x35, 0x32, 0x20, 0x2c, 0x2f, 0x36, 0x25,
            0x20, 0x2c, 0x25, 0x34, 0x34, 0x25, 0x32, 0x20, 0x29, 0x33, 0x2e, 0x27,
            0x34, 0x20, 0x27, 0x29, 0x36, 0x25, 0x2e, 0x20, 0x29, 0x2e, 0x20, 0x34,
            0x28, 0x25, 0x20, 0x26, 0x2f, 0x32, 0x2d, 0x20, 0x2f, 0x26, 0x20, 0x28,
            0x29, 0x27, 0x28, 0x2c, 0x39, 0x20, 0x2f, 0x22, 0x26, 0x35, 0x33, 0x23,
            0x21, 0x34, 0x25, 0x24, 0x20, 0x3,  0x2c, 0x20, 0x29, 0x33, 0x20, 0x29,
            0x34, 0x20, 0x32, 0x25, 0x21, 0x2c, 0x2c, 0x39, 0x20, 0x21, 0x20, 0x2c,
            0x2f, 0x36, 0x25, 0x20, 0x2c, 0x25, 0x34, 0x34, 0x25, 0x32, 0x3f, 0xa,
            0x9,  0x20, 0x24, 0x2f, 0x2e, 0x27, 0x34, 0x20, 0x2b, 0x2e, 0x2f, 0x37,
            0x2c, 0x20, 0x22, 0x35, 0x34, 0x20, 0x37, 0x28, 0x21, 0x34, 0x20, 0x9,
            0x20, 0x24, 0x2f, 0x20, 0x2b, 0x2e, 0x2f, 0x37, 0x20, 0x29, 0x33, 0x20,
            0x34, 0x28, 0x21, 0x34, 0x20, 0x9,  0x20, 0x2c, 0x2f, 0x36, 0x25, 0x20,
            0x39, 0x2f, 0x35, 0x21, 0x20, 0x3c, 0x33, 0xa };
    
    int main ()
    {
        for (int i = 0; i < 152; i++)
        {
            char adder1 = addarr1[i];
    
            char adder2 = addarr2[i];
    
            char to_print = (char)adder1 + adder2;
    
            printf ("%c", to_print);
        }
        return 63;
    }
    
    
      

    I guess I should have kept the recursion and straightened it out in the next step, but now that it's done...

    The next step will just have an array of the characters that would be printed, so I'll leave it here.

  • Here's it with some amount of de-obfuscation:

     C
        
    #include <stdio.h>
    short i = 0;
    const long b[]
        = { 0xd60,  0x3200,  0x1ca8, 0x74e2, 0x9c,   0x66e8, 0x5100,  0x14500,
            0x63b8, 0x49c6,  0xe0,   0x6200, 0x75e8, 0x57a6, 0xe8,    0x4300,
            0x4500, 0x63b8,  0x49ea, 0xc6,   0x548e, 0x22,   0x75e8,  0x57a6,
            0xc6,   0x2fae,  0x7486, 0x8a,   0xd72,  0x4f9c, 0x63c6,  0x4ea2,
            0x809c, 0x66e8,  0x5100, 0x5c00, 0x71a2, 0x51b8, 0x4e9e,  0xc6,
            0x6200, 0x70c4,  0x8022, 0x7d00, 0x439c, 0x63b8, 0x6ae0,  0x54c0,
            0x47e8, 0xe2,    0x5192, 0x6fc4, 0x4900, 0x60e8, 0x100ca, 0x14fe8,
            0x6000, 0x44e92, 0x6300, 0x57c4, 0xae,   0x4ecc, 0x62de,  0xc6,
            0xafae, 0x70c4,  0x9e,   0x4ec6, 0x639c, 0x5100, 0x4ecc,  0x74a2,
            0x9e,   0x54e8,  0x7100, 0x608a };
    const long n = 9147811012615426336;
    long
    main ()
    {
        if (i < 152)
        {
            char shifter;
            if (i % 2 == 0)
            {
                shifter = 8;
            }
            else
            {
                shifter = 1;
            }
            char adder1 = (b[i >> 1] >> shifter) & 64;
    
            char adder2 = (n >> (b[i >> 1] >> shifter)) & 63;
    
            char to_print = (char)adder1 + adder2;
            i++;
            main ();
            printf ("%c", to_print);
        }
        return 63;
    }
    
      

    Needless to say, the return value doesn't matter any more. So you can change it to 0 or 69 depending upon your preferences.

  • Some kind of Caesar cipher you made?

    fIy uo rolevl teet rsi'n tigev nnit ehf ro mfoh gilh yboufcstadeC ,sii terlayla l vo eelttre ? Iod'n tnkwo ,ub thwtaI d onkwoi shttaI l vo eoy!u< 3%

  • 2 Kinds

    Jump
  • And people say pointers are hard.

  • You get all Lemmy results! Yaay!

    Sorry, that's really all there's to it.