Shoutbox

Hello,

Tihs sfufuptlg takler, sbarlmecd up the midlde ptars of words so that dtpiise mlelgsnipiss, you can read them elfrleosftsy!

or if you prefer:

This stuffplug talker, scrambled up the middle parts of words so that dispite misspellings, you can read them effortlessly!

It is based on the concept: http://216.239.59.104/search?q=cache:R79FQj60fnkJ...t.davis/Cmabrigde/
I found this fascinating so I made a talker to do it for me.

Save as "talker.unread.js" in your StuffPlug NG Talker folder and use:
/xtalk unread <your text here>
or to make all your messages use it;
/xautotalker unread
to use!

code:

---

// Unreader written by Improfane 2005
// Please do not remove this message
// original concept: http://216.239.59.104/search?q=cache:R79FQj60fnkJ...t.davis/Cmabrigde/ (Google Cache)

var words = /[a-z]+/gi ;
// regular expression to grab all words

function talker(input) {
return readable_scrambler(input) ;
}

function readable_scrambler(input) { // makes a readable scramble of an entire string
var matches = input.match(words) ; // list of all words
for (cur_word=0; cur_word < matches.length ; cur_word++) { // cycle through each word
    word = matches[cur_word] ;
    input = input.replace(word, readable_word_scramble(word) ) ;
    }
return input ;
}

function readable_word_scramble(word) { // scrambles the middle part of a string
cur_word_length = word.length ; // current word length

if (cur_word_length>3) { // prevents redundant scrambling
cur_word_middle = word.substring(1,cur_word_length-1) ; // the middle part of the word, from the 2nd letter to the 2nd to last letter
new_middle = scramble(cur_word_middle) ; // scrambles the middle word
return word.replace(cur_word_middle,new_middle) ;
} else return word ;
}

function scramble(input) { // scrambles any input
// written by Improfane 2005
if (input.length<=1) return input ; // nothing at all to scramble
var new_word = "" ;

for (cur_letter=0 ; cur_letter = input.length ; cur_letter++) { // cycle through each letter
random_letter = input.charAt(ranNum(0,input.length)) // get random letter from the possible characters available
input = input.replace(random_letter,"") ; // remove the used letter from the possible characters available
new_word += random_letter ; // adds the random letter to the new string
    }
return new_word ;
}

function ranNum(nFrom,nTo) {
return Math.floor(nFrom + (nTo-nFrom + 1) * Math.random()) ;
// returns a random number
}

---

It is having some problems with 3 letter words, I'll figure it out, eventually.

[ I haven't visited these forums for a while so here is my response to CookieRevised's post: http://shoutbox.menthix.net/showthread.php?tid=51...d=548567#pid548567 ]
I wrote a generic scrambling function that is irrelevant to the talker above.

All this does is scramble whatever you feed it.

The talker, takes the 2nd letter to the 2nd to last letter and feeds it to the scrambler.

Understand? This is why only the middle letters get scrambled. However, I encountered a bug where despite this, the entire 3 letter string would be passed and therefore scrambled: "the" -> "teh" where instead it should be "the" as the "e" has nowhere to move.

That's why there isn't anything flawed with the scrambler.

I've realised that if it was to be completely modular, the actual talker would be a separate module, named something like "ReadableMispell()" that would itself check the letter length, and inturn call upon the scrambling module.

You didn't say that, you said my scrambling routine was broken.

Instead, I only used a scrambler routine that I've already written in a previous project. Where the length was irrelevant - it was a password generator I believe.

What you are saying would be correct if my scrambler was specific to this project, alas it is not, the check of length would be redundant.

If you want to talk efficiency, I understand your point as scrambling twice is pointless when you can simply check length and therefore valid. I didn't realise you meant this.

After re-reading this (just checking my Google trail)
It doesn't seem to be understood what I mean by modularity. J-Thread wants to remove all the functions and put it as messiness. Cookie didn't need to be an ass about it, either. Explain in English rather than randomly exclaim 'Fix your scrambler' and not tell me how. As far as I'm aware, the word scrambler is not broken. The word one was.

I'd rather not tie the the talker and the word randomizer together. I'd rather be able to reuse it later on. Hence the generic word and scrambler functions.

The only bug was the making [the] to [teh]. The length check is necessary to fix this unless you put word dependent stuff in the first loop. Cleanliness and readability is my mantra.

You can use the scramble function above to mix up any string of characters, for example:
a password, scramble("abcdefghijklmnopqrstuvwxyz0123456789").substring(0,8);

In hindsight, the word check should probably be in the main loop.