Oh my blog! Whee!

Wrong by design

  • jan 28

    Ok, I got to thinking about how to pronounce Esolanean words.

    Two things go into this (at least): how each letter is pronounced, and which syllables to stress.

    I already have some indications as to both, since I’ve been using the few words I have in my mind for several years.

    /SINT/ is stressed.

    In /SINTor/, the first syllable is still stressed, but in /toMAL/ the second syllable is. Hm. /KATor/ stresses the first syllable as well, so it looks like the /-or/ suffix doesn’t move the stress.

    /sintAro/originally stressed the second syllable, but I rather like /SINTaro/ as well, which would work with a general rule that suffixes do not move the stress. /BENapak/ stresses the first syllable, so that’d work if /-apak/ is one or more suffixes. /Ben/ meaning <wander> is pretty cool too, since /ben/ mean leg (or legs) in Danish. I’m not aiming for a language like Danish, but I like cross-language puns.

    So it looks like stress is on the last syllable of the stem word for one- and two-syllable stems. Looking over the longer words I’m generating, I have a feeling that the rule might be to stress the second syllable for any stem longer than one syllable.

    For the other part, pronounciation, I’ve been trying to figure out at least some of that whole IPA thing.

    Looks like most of the letters I’m using represent sounds that have the same characters in IPA, so that makes it quite a bit easier, but one thing popped up, at least: /r/ is pronounced [ɹ].

    WordBuilder naturally supports unicode characters, so that shouldn’t be a problem… erm. Oops. Unicode support is broken in v1.5 because of the syntax coloring. New version with support for IPA characters is coming in a moment, as I have the fix implemented.

    After that, I added a new rule to my script – I figured some extra rules, such as /ar/ is pronounced like a long [a], and /r/ is trilled after /p/ and /o/, unless at the end of the word, where /or/ is just a long [ɐ]:

    rule pronounciation {
     translate {
      a r # => a ː
      o r # => ɐ ː
      o r => o !r // escape some r's
      p r => p !r
      r => ɹ
      !r => r // unescape after most r's are fixed.
      t => t̪ // t is dental.
     }
    }
    

    And added a branch at the end of my noun rule:

    rule noun {
     rule base
     rule noun-ending
     rule cleaning
     branch Pronounciation pronounciation
    }
    

    And finally added a column to my presentation:

    column Pron. Pronounciation

    Now, I get IPA pronounciation next to my words when I generate, albeit incomplete, because I haven’t worked all the way through the alphabet. More mappings in the translate command, and I’ll be done.

    Oh, and I realized a mistake I’d made earlier, when introducing the double consonant syllable rule – since it had the same weight as the other syllable rule, it got hit a lot of the time also for the first syllable, meaning that an overweight of the words started with a vowel. I’ve adjusted the weight so that it now generates a more tolerable amount of vowel-starting words, as well as fewer double consonants.

    Words now look like this:

    • merkamror [meɹkamɹɐː]
    • roben [ɹoben]
    • tepar [t̪epaː]
    • kamottepmor [kamot̪tepmɐː]
    • pisosbikar [pisosbikaː]
    • selnersin [selneɹsin]
    • ser [seɹ]
    • eran [eɹan]
    • lipikoen [lipikoen]
    • kaknotser [kaknot̪seɹ]
  • jan 24

    I ended up last night with a script that generated some decent syllables. Alas, when combined, they didn’t always work very well.

    So I changed my script a bit:

    tokens vowel a e i o
    tokens consonant b k l m n p r s t
    tokens noun-ender r n
    
    rule base {
     loop 0 1 1 5[2] 2[3] {
     rule syllable
     }
    }
    
    rule noun {
     rule base
     rule noun-ending
    }
    
    rule noun-ending {
     loop 0 0 1 1 1 {
     token consonant
     }
     token vowel
     token noun-ender
    }
    
    rule syllable {
     loop 0 0 1 1 1 {
     token consonant
     }
     token vowel
     loop 0 0 6[1] {
     token consonant
     }
    }
    
    rule syllable {
     translate {
     a # => a $consonant
     e # => e $consonant
     i # => i $consonant
     o # => o $consonant
     }
     loop 0 0 1 {
     repeat
     }
     token vowel
     loop 0 0 6[1] {
     token consonant
     }
    }
    
    startingrule noun 50
    
    

    Now, I’ve added a new variation of the syllable rule so as to make double consonants more likely. I found that ever so often, the rule would be applied to a syllable ending with a vowel, so I added the translate command to make sure there was a consonant at the end before repeating.

    That’s a lot better, but there are still some consonant pairs that I dislike. So I added this rule to the script:

    rule cleaning {
     translate {
     [b p] k => m k
     t k => s k
     [b p] n => n n
     b p => p p
     p b => b b
     l r => l l
     }
    }
    

    Which solves at least most of my problems. Words now look like this:

    • arpakpir
    • elobrar
    • akinan
    • oppin
    • abor
    • itokimkon
    • kanikbamen
    • oksan
    • ikabmemir
    • eppobin
    • an
    • etetelen
    • inter
    • orser
    • itannesmar
    • nabsipporon
    • imsinror
    • ekeon
    • obbason
    • mibosepir
    • ibasbir

    Not bad – and with a pretty uniform feeling, I think.

  • First scripts

    Filed under Esolanean
    jan 23

    Ok, so far I’ve been picking out consonants and vowels. I’m pretty sure I’ll need a few more, but I figure I might as well try and generate a few words.

    Here’s a first very simple script:

    tokens vowel a e i o
    tokens consonant b k l m n p r s t
    tokens noun-end r n
    
    rule noun {
     token consonant
     token vowel
     token noun-end
    }
    
    startingrule noun 50
    
    

    Which sadly generates very simple, one-syllable words. One moment!

    tokens vowel a e i o
    tokens consonant b k l m n p r s t
    tokens noun-end r n
    
    rule noun {
     loop 1 5[2] 4[3] 2[4] {
     rule syllable
     }
     token noun-end
    }
    
    rule syllable {
     token consonant
     token vowel
    }
    
    startingrule noun 50
    
    

    There, that’s better – although the syllable structure is a bit simple – CV isn’t much for variation. Here’s a new syllable rule for (C)V(C)

    rule syllable {
     loop 0 0 3[1] {
      token consonant
     }
     token vowel
     loop 0 0 6[1] {
      token consonant
     }
    }
    
    
    

    That gives me words like

    • poenin
    • repokor
    • loriten
    • lobkosrokor
    • lopkoer
    • botipkiir
    • obpaen
    • opotan
    • resereor
    • ikolkoen
    • ilsian
    • osin
    • bitor
    • setepar

    Some of them aren’t exactly great, (ikolkoen? and botipkiir??) but it’s a start. Maybe I can clean up some of it with further processing.