Memzakian Code

[~Memzak~]

This is what I did in some of my spare time
I know dumb, but anyways (we'll discuss how I structured the code later)

<script=MemzakianScript>

#CompileData
{
(UBBC);
  {
    (b);
    (i);
    (u);
    (s);
    (glow);
    (shadow);
    (move);
    (pre);
    (left);
    (center);
    (right);
    (hr);
    (size);
    (font);
    (color);
    (youtube);
    (blockquote);
    (url);
    (img);
    (email);
    (table);
    (tr);
    (td);
    (sup);
    (sub);
    (tt);
    (code);
    (quote);
    (list);
  }
(UBBC|Added);
  {
    (Spoiler);
    (Hover);
  }
}

#PrescriptSet
  {
   #VariableOccurrences 
      {
           (b~1);
           (i~0);
           (u~0);
           (s~0);
           (glow~0);
           (shadow~0);
           (move~0);
           (pre~0);
           (left~0);
           (center~0);
           (right~0);
           (hr~0);
           (size~0);
           (font~0);
           (color~0);
           (youtube~0);
           (blockquote~0);
           (url~0);
           (img~0);
           (email~0);
           (table~0);
           (tr~0);
           (td~0);
           (sup~0);
           (sub~0);
           (tt~0);
           (code~0);
           (quote~1);
           (list~0);
           (Spoiler~0);
           (Hover~0);
       }     
   #WritingScript
       {
#1
     [**Posted by Memzak**];
#2
     [**Hey guys, I have just invented a new script and I am testing it here! I hope you enjoy!**];
#3
     [**And that was an example of this script...**];
#4
     [**You're PC doesn't have the correct software to use memzakian script, please download them from memzak.**];
       }

#FinalCheck
  {
     #OrderScript
         {
               (Start[Variable=b]);
               (Writing[#1]*Inside[Variable=b]*);
               (End[Variable=b]);
               (Start[Variable=quote]);
               (Writing[#2]*Inside[Variable=quote]*);
               (End[Variable=quote]);
               (Writing[#3]*Inside[none]*);
         }
     #CheckCompatibility 
          If; 
               [Compatibility=0];
          Then; 
               {
                    [Replace];
                        {
                            (Start[Variable=b]);
                            (Writing[#1]*Inside[Variable=b]*);
                            (End[Variable=b]);
                            (Start[Variable=quote]);
                            (Writing[#2]*Inside[Variable=quote]*);
                            (End[Variable=quote]);
                            (Writing[#3]*Inside[none]*);
                        }
                    [With];
                        {
                             (Writing[#4]*Inside[none]*);
                        }
               }
          Else;
               {
                   #Continue 
               }
 }

#RunScript
 {
     If;
         {         
               [Error|Mesage];
          }
     Then;
           {
               (Open[TroubleShooting.MZKS]);
               (Run[TroubleShooting.MZKS]);
           }
     Else;
           {
               #Rest
           }
 }

</script>

ALL OF THAT comes out are this:
_____________________________________________________

Posted by Memzak

Hey guys, I have just invented a new script and I am testing it here! I hope you enjoy!

And that was an example of this script...

[The Dark Master]

What does it do?

[I wuv M4( Satar Jaèoèdoæ)]

Is runscript runescript?

[Saza]

Hey?
Theres two of this thread

[~Memzak~]

There are?
lol, I'll delete one of them...

and no, it is runscript

I made that whole thing up XD
it Memzakian script, it does absolutely nothing...

I just felt like making it...

[dbsndust]

So? What are you going to do about it? Delete the other one maybe ? So I don't get this. Just like Ozone's dedicated server post. Just plain

[~Memzak~]

It's just a random code (with no meaning)

that I made up myself...

this coding language doesn't even exist...

I just felt like making it up...

[ROBiT]

Your functional processing is illogical: It checks if the user can run the code, which would never execute if the user couldn't, because the computer would just see text.

[~Memzak~]

Oh, I see, so I should get rid of the:

     #CheckCompatibility 
          If; 
               [Compatibility=0];
          Then; 
               {
                    [Replace];
                        {
                            (Start[Variable=b]);
                            (Writing[#1]*Inside[Variable=b]*);
                            (End[Variable=b]);
                            (Start[Variable=quote]);
                            (Writing[#2]*Inside[Variable=quote]*);
                            (End[Variable=quote]);
                            (Writing[#3]*Inside[none]*);
                        }
                    [With];
                        {
                             (Writing[#4]*Inside[none]*);
                        }
               }
          Else;
               {
                   #Continue 
               }

For it to make some] logical sense...

[Sandmaster]

Well, it could be for the sake of irony!