Official Everybody Edits Forums

Jabatheblob1

Member

Joined: 2015-03-01

Posts: 856

[Tutorial/Explained?] Writing Letters In EE

▼Long Version

A very popular topic that has been recommended for me to make a tutorial on is writing letters in the game. I began to do so and write code when I remembered that someone already had made this code and I even used it in my first couple bots without knowing how it worked in the least. I decided to dig up the topic and find out who made it and I couldn't find who made it. And looking at the code now, I realized a lot of things about the code that I was to "correct." I put quotes around the word because I don't want to bash someone's code but rather help inform people who may just start programming on some good habits. The creator may have put some things in there just to throw off people, or that may be just how they program which is why I want to make it clear, I am not bashing on this code, but just explaining and cleaning it up a bit. I am making this post also because this was code that I just passed off as "too advanced for me" when I first started programming and it feels good being able to decipher other people's work and understand the code.

There's the topic I found the code^

▼Short Version

Rewritting someone's writing letters code.

Skip to the bottom if you just want an explanation on how all this works.

▼Original Code(if you don't want to switch between tabs)

 if (msg.StartsWith("!write "))
                    {
                        string[] strArray = msg.Split(new char[] { ' ' });
                        string Stuffz = msg.ToLower();
                        string Data = msg.Replace("!write ", "");
                        string[] uhthepos = msg.Split(' ');
                        Bitmap bitmap = new Bitmap(Environment.CurrentDirectory+ "/RGfont1.bmp");
                        string str2 = uhthepos[4]; //Text
                        int num = Convert.ToInt32(uhthepos[1]); //X from world
                        int num2 = Convert.ToInt32(uhthepos[2]);//Y from world
                        int num3 = Convert.ToInt32(uhthepos[3]); //block
                        int num4 = 0;
                        int num5 = 0;
                        for (var si = 4; si < uhthepos.Length; si++)
                        {
                            str2 = uhthepos[si] + " "; ;
                            for (int i = 0; i < str2.Length; i++)
                            {
                                uint num7 = str2[i];
                                int num8 = (int)((num7 / 0x10) * 10);
                                int num9 = (int)((num7 % 0x10) * 7);
                                bool flag = false;
                                int num10 = 0;
                                while (!flag)
                                {
                                    switch (bitmap.GetPixel(num9 + num10, num8 + num5).R)
                                    {
                                        case 120:
                                            num5 = -1;
                                            flag = true;
                                            break;
 
                                        case 180:
                                            num5 = -1;
 
                                            flag = true;
                                            break;
 
                                        case 0:
                                            conn.Send(roomkey, new object[] { 0, num + num4, num2 + num5, num3 });
                                            Thread.Sleep(15);
                                            break;
 
                                        case 0x6f:
                                            num5 = -1;
                                            flag = true;
                                            break;
                                    }
                                    if (num5 < 8)
                                    {
                                        num5++;
                                    }
                                    else
                                    {
                                        num4++;
                                        num10++;
                                        num5 = 0;
                                    }
 
                                }
                                num4++;
                            }
                        }
                    }

▼Bitmap(to go with the code)

Changes:

▼1). There's three lines of code that serve no use to the actual function of the command.

Not only do they serve no purpose, but two of the names don't describe the function very well. Whenever labeling objects, you(for the most part) always want to label the object with a label that also describes the function.

▼Example

if(m.Type=="say")
{
	string msg = m.GetString(1);
}

The name 'msg' describes that that is the message incoming from other users. (May sound basic, but remember this is also a tutorial to help people get in good habit.)

▼Updated Code

 if (msg.StartsWith("!write "))
                    {
                        string[] uhthepos = msg.Split(' ');
                        Bitmap bitmap = new Bitmap(Environment.CurrentDirectory+ "/RGfont1.bmp");
                        string str2 = uhthepos[4]; //Text
                        int num = Convert.ToInt32(uhthepos[1]); //X from world
                        int num2 = Convert.ToInt32(uhthepos[2]);//Y from world
                        int num3 = Convert.ToInt32(uhthepos[3]); //block
                        int num4 = 0;
                        int num5 = 0;
                        for (var si = 4; si < uhthepos.Length; si++)
                        {
                            str2 = uhthepos[si] + " "; ;
                            for (int i = 0; i < str2.Length; i++)
                            {
                                uint num7 = str2[i];
                                int num8 = (int)((num7 / 0x10) * 10);
                                int num9 = (int)((num7 % 0x10) * 7);
                                bool flag = false;
                                int num10 = 0;
                                while (!flag)
                                {
                                    switch (bitmap.GetPixel(num9 + num10, num8 + num5).R)
                                    {
                                        case 120:
                                            num5 = -1;
                                            flag = true;
                                            break;
 
                                        case 180:
                                            num5 = -1;
 
                                            flag = true;
                                            break;
 
                                        case 0:
                                            conn.Send(roomkey, new object[] { 0, num + num4, num2 + num5, num3 });
                                            Thread.Sleep(15);
                                            break;
 
                                        case 0x6f:
                                            num5 = -1;
                                            flag = true;
                                            break;
                                    }
                                    if (num5 < 8)
                                    {
                                        num5++;
                                    }
                                    else
                                    {
                                        num4++;
                                        num10++;
                                        num5 = 0;
                                    }
 
                                }
                                num4++;
                            }
                        }
                    }

▼2). The code is inside a command.

Now this is more of personal preference. I like to have more voids that are used multiple times than chunks of code in my onMessage. This code was organized by a #region which makes it more managable, besides that, i'd rather have the code in a void.
Now to move all this code into a void, there's two ways a person could go about this. One way messes with the code less, and the other adds parameters to the void. I chose to add parameters, in order to do so I had to remove num, num2, num3 and instead include the three integers in the parameters with the labels of 'x', 'y', and 'bid'.

Since I took out the three integers, I need to replace any case they're found in the code with their new names.(Not shown in changes for tedious sake)
Also since I added the parameters, the msg string no longer has to contain the three numbers making a few changes:

▼Changes

This string can be set to an empty string since the msg string contains the actual message that is desired to be displayed on EE.

The 4 needs to be changed to 0 because there's no uneeded information in the string anymore.

▼Updated Code

public void writeMessage(string msg, int x, int y, int bid)
                    {
                        string[] uhthepos = msg.Split(' ');
                        Bitmap bitmap = new Bitmap(Environment.CurrentDirectory+ "/RGfont1.bmp");
                        string str2 = "";
                      
                        int num4 = 0;
                        int num5 = 0;
                        for (var si = 0; si < uhthepos.Length; si++)
                        {
                            str2 = uhthepos[si] + " "; ;
                            for (int i = 0; i < str2.Length; i++)
                            {
                                uint num7 = str2[i];
                                int num8 = (int)((num7 / 0x10) * 10);
                                int num9 = (int)((num7 % 0x10) * 7);
                                bool flag = false;
                                int num10 = 0;
                                while (!flag)
                                {
                                    switch (bitmap.GetPixel(num9 + num10, num8 + num5).R)
                                    {
                                        case 120:
                                            num5 = -1;
                                            flag = true;
                                            break;
 
                                        case 180:
                                            num5 = -1;
 
                                            flag = true;
                                            break;
 
                                        case 0:
                                            conn.Send(roomkey, new object[] { 0, x + num4, y + num5, bid });
                                            Thread.Sleep(15);
                                            break;
 
                                        case 0x6f:
                                            num5 = -1;
                                            flag = true;
                                            break;
                                    }
                                    if (num5 < 8)
                                    {
                                        num5++;
                                    }
                                    else
                                    {
                                        num4++;
                                        num10++;
                                        num5 = 0;
                                    }
 
                                }
                                num4++;
                            }
                        }
                    }

▼3). Mother of labels.

This is probably the one that confused me the absolute most when I first started programming. It's hard to keep track of what 'num' does what when there's 10 of them!
That is also why it took me a while to figure out what was going on here. But eventually I was able to relabel everything:

Changed to: split

Changed to: text

Changed to: eeSendX

Changed to: yBitMod

Changed to: t

▼Explanation

I didn't want to leave this unaddressed. I mentioned earlier that you should nearly always label objects with it's function. This is one of the cases where it really doesn't matter. For loops usually have the letter 'i' as the index, for it means 'index'. In this case, 'i' was already used, so I just needed another letter that would work the same as 'i'.

Changed to: character

Changed to: xBitStart

Changed to: yBitStart

Changed to: 111

▼Explanation

I think this is a case of the creator messing with people. Notice in this picture:

All the numbers in each case is in decimal except the last one. For some reason, the creator decided to change the last one to hexidecimal for 111. I decided to change it back to decimal for simplicity sake. Again, not sure if this was intentional or not, but it bugged me.

Now once again, I am not going to point out everywhere where you should replace all of these since that would be tedious. I do have the updated code though, some pieces may be shifted around but it's all with the same function just reorganized.
(I also am removing this semicolon...)

▼Updated Code

		    public void writeMessage(string msg, int x, int y, int bid)
                    {
                        string[] split= msg.Split(' ');
                        Bitmap bitmap = new Bitmap(Environment.CurrentDirectory+ "/RGfont1.bmp");
                        string text = "";
                        int eeSendX = 0;
                        for (var t = 0; t < split.Length; t++)
                        {
                            text = split[t] + " "; 
                            for (int i = 0; i < text.Length; i++)
                            {
                                uint character = text[i];
				int xBitStart = (int)((character % 0x10) * 7);
                                int yBitStart = (int)((character / 0x10) * 10);
                                bool flag = false;
                                int xBitMod = 0;
				int yBitMod = 0;
                                while (!flag)
                                {
                                    switch (bitmap.GetPixel(xBitStart + xBitMod, yBitStart + yBitMod).R)
                                    {
                                        case 120:
                                            yBitMod = -1;
                                            flag = true;
                                            break;

                                        case 180:
                                            yBitMod = -1;
                                            flag = true;
                                            break;
 
                                        case 0:
                                            conn.Send(roomkey, new object[] { 0, x + eeSendX, y + yBitMod, bid });
                                            Thread.Sleep(15);
                                            break;
 
                                        case 111:
                                            yBitMod = -1;
                                            flag = true;
                                            break;
                                    }
                                    if (yBitMod < 8)
                                    {
                                        yBitMod++;
                                    }
                                    else
                                    {
                                        eeSendX++;
                                        xBitMod++;
                                        yBitMod = 0;
                                    }
                                }
                                eeSendX++;
                            }
                        }
                    }

▼4). Bitmap is a little weird

Now to explain this, there needs to be a little bit of an explanation. The way that each letter is found in this bitmap is unique to say the least.

This is where it all starts. The code takes the character's decimal number and divides it by 16 in hexidecimal which is 0x10. Why it's in hexidecimal... idk. I didn't change it. The reason why it is divided by 16 is because, well one, who doesn't like the number 16, I could write an essay on the number 16, but more importantly two, the number of characters in a row in the bitmap.

There's 16 characters in each row, which explains why it is divided by 16. But why is xBitStart then multiplied by 7? Well this has to do with how many pixels are in each character at a Maximum(This is the distance between the two dark gray lines).
On the X-axis, each character is a maximum of 7 pixels while on the Y-axis, each character is a maximum of 10 pixels. That explains why each variable is multiplied by what it is. So you may be asking why I made this a topic if nothing is wrong... Well notice the top part of the bitmap and the two rows of just purple? Why is that there? Well if we were to follow the formula to find the start pixel for the character 'space' you take the decimal number of the character on the ascii table which is 32, and divide it by 16 which is 2 and multiply by 20. And by golly, that's exactly the height of the purple section. But why have all that purple? Why not subtract the yBitStart by 20 and get rid of all that purple:


Along with that change, I also made the space character only 1 pixel wide so when typing, instead of a 6 block space, it is now a 3 block space, but this is more a preference.

▼Decimal Number Explanation

As mentioned before, a character has a decimal number. What I mean by that, is it has a base 10 number that represents that number in the Ascii table. The Ascii table is a table that corresponds a character(or function) to a number in decimal and hexidecimal.

If you look along the 'Decimal" column and follow it to the number 16, you see the 'Hex' column say '10'. 10 is the hexidecimal representation of the decimal number 16. So in code, to write hexidecimal, you type '0x' first, then the hexidecimal. So in terms of pseudocode, xBitStart is a uint that is assigned a decimal that's based on the character in the ascii table, then divided by 0x10, which is decimal 16, and then multiplied by 7. This is all to find the correct letter in the bitmap... The explanation is continued further before the spoiler.

▼Updated Code

		    public void writeMessage(string msg, int x, int y, int bid)
                    {
                        string[] split= msg.Split(' ');
                        Bitmap bitmap = new Bitmap(Environment.CurrentDirectory+ "/RGfont1.bmp");
                        string text = "";
                        int eeSendX = 0;
                        for (var t = 0; t < split.Length; t++)
                        {
                            text = split[t] + " "; 
                            for (int i = 0; i < text.Length; i++)
                            {
                                uint character = text[i];
				int xBitStart = (int)((character % 0x10) * 7);
                                int yBitStart = (int)((character / 0x10) * 10)-20;
                                bool flag = false;
                                int xBitMod = 0;
				int yBitMod = 0;
                                while (!flag)
                                {
                                    switch (bitmap.GetPixel(xBitStart + xBitMod, yBitStart + yBitMod).R)
                                    {
                                        case 120:
                                            yBitMod = -1;
                                            flag = true;
                                            break;

                                        case 180:
                                            yBitMod = -1;
                                            flag = true;
                                            break;
 
                                        case 0:
                                            conn.Send(roomkey, new object[] { 0, x + eeSendX, y + yBitMod, bid });
                                            Thread.Sleep(15);
                                            break;
 
                                        case 111:
                                            yBitMod = -1;
                                            flag = true;
                                            break;
                                    }
                                    if (yBitMod < 8)
                                    {
                                        yBitMod++;
                                    }
                                    else
                                    {
                                        eeSendX++;
                                        xBitMod++;
                                        yBitMod = 0;
                                    }
                                }
                                eeSendX++;
                            }
                        }
                    }

▼5). Add notes.

Something that is a really good habit to get into when working with other people and they have to read large chunks of your code is to add short notes in your code to explain what's going on if it isn't all too simple. (In the updated code, the source of the bitmap is different, along with an extra parameter, this is for different fonts in the future)

▼Updated Code(Taken straight from my program after all corrections)

 public void writeMessage(string msg, string font, int x, int y, int bid)
        {
            string[] split = msg.Split(' ');//Splits message by spaces
            Bitmap bitmap = new Bitmap(Environment.CurrentDirectory + @"\Fonts\" + font + ".bmp");
            int eeSendX = 0;//established here so that in the end after the while loop, an extra int can be added so that there's space between each letter
            string text = "";
            for (var t = 0; t < split.Length; t++)//goes through each word
            {
                text = split[t] + " ";
                for (int i = 0; i < text.Length; i++)//goes through each character of each word
                {
                    uint character = text[i];//character's decimal number
                    int xBitStart = (int)((character % 0x10) * 7);//top left corner of the character's startX
                    int yBitStart = (int)((character / 0x10) * 10) - 20;//top left corner of the character's startY. Subtracted 20 so that the new modified bitmap is usable that has less purple space.
                    bool flag = false;//this is for if the loop runs into a light gray, dark gray, or purple area to signal that there is no more pixels of the character left
                    int yBitMod = 0;
                    int xBitMod = 0;
                    while (!flag)
                    {
                        switch (bitmap.GetPixel(xBitStart + xBitMod, yBitStart + yBitMod).R)//This only takes the Red out of the RGB of the pixel, instead of comparing all three numbers, just one will do
                        {
                            case 120: //Dark gray
                                yBitMod = -1; //Whenever gray or purple is touched, the flag is set to true so that it will break the loop and go to the next character
                                flag = true;
                                break;

                            case 180: //Light gray
                                yBitMod = -1;
                                flag = true;
                                break;

                            case 0: //Black, this is the actual character
                                con.Send("b", new object[] { 0, x + eeSendX, y + yBitMod, bid });
                                Thread.Sleep(15);
                                break;

                            case 111: //Purple
                                yBitMod = -1;
                                flag = true;
                                break;
                        }
                        if (yBitMod < 8)//This makes sure that it only reads enough pixels in the y direction(The tallest character is 7 characters)
                        {
                            yBitMod++;
                        }
                        else
                        {
                            //When it does exceed that 7 pixel limit, it shifts over to the right one pixel and reads the next line of pixels
                            //The x value that's sent and the x value that's read in the bitmap are seperate because there needs to be spaces between the letters which is added just a few lines down
                            eeSendX++;
                            xBitMod++;
                            yBitMod = 0;
                        }
                    }
                    eeSendX++;//The space between letters is added when the character is done being read in the bitmap.
                }
            }
        }

Explanation:

▼Explanation

So if you just skipped here and didn't read the changes, this may make a little less sense than those who read all the changes. But since I don't expect everyone to read all the changes, i'll give a overview of how this code works including the ascii table and how that determins how the bot finds the character in the bitmap.

First, starts with the letter:

The character gets converted to a number that is represented in the ascii table:

All characters from space to '~' is included(which must have taken patience to do). Now that decimal number ranges from 32-126 as seen in the table. That decimal number is divided by 16 since there are 16 characters in a row, and 16 is a puurrteey number. Now to make that number the size of a character in everybody edits, you need to multiply that number by the size of the character. So in the X-axis, the number is 7, and in the Y-axis the number is 10. Now since this is going off of the ascii table, you're going to be off by 20 in the Y-axis, which explains the two rows of purple boxes in the original bitmap. To fix this, I subtracted 20 from the yBitStart value and got rid of the purple in the bitmap.
Now this only gives you the start location(top left) of the character's box. For exmaple, let's say that you wanted to write the letter 'a' in everybody edits. Since it is lowercase the decimal number is 97. To find the xBitStart you actually get the remainder if you were to divide 97 by 16. What I mean is 97/16=6.0625 , to find the remainder, take the decimal and multiply it by 16: 0.0625*16=1. Since the remainder is 1, that means that the start is in the second colomun(the first column would be a remainder of 0). To get the pixel location you multiply the value by the width of the character, which is 7 in this bitmap. Making the xBitStart = 7. Now for the yBitStart, almost the same thing happens but instead of the remainder, you just divide by 16 and convert it to an int which rounds the decimal down. Then multiply by 10 because that's the height of the character. After that has been done, you subtract 20 since the characters are ofset by 20 pixels. This puts the yBitStart = 40.

Now that we have the start position of the character, there needs to be a loop to keep looping through the character until it hits a gray area that signifies that the character is done and there's nothing else to read. To do this, there's a few variables that come into play.



Now a couple things to note, is that there's only one yBitMod that is used when sending blocks but there is eeSendX and xBitMod. That's due to the tiny space that is added between letters, which is added at the bottom of the picture.
Pretty much all this code is saying is yBitMod is set to 0, and is incremented by 1 until it reaches 8 which is the biggest character on the bitmap, then it gets reset to 0 and both x values get incremented by one which shifts over the "reading" by 1 so that it reads a whole new line. It does this until it reaches, light gray, dark gray, or purple, which it then breaks the loop and sets flag to true which then moves to the next character of the word. Another thing to notice is the added " "; in each word:

This is because all the words are split by a space so it cuts out all the spaces in the array. This just simply puts that space back into the string after each word.
Once a pixel that is black is found, it is immedietly sent and a Thread.Sleep is in place to prevent too many blocks to be sent at once.

This was not the complicating part that made this code tough to understand from a novice standpoint but rather the labeling of the objects. This just goes to show how notes and labeling can improve code and turn something that is a challenge to undesrtand, into a piece of code that is simplified and easy for anyone to understand(hopefully..)

Also to mention, this code is not perfect. There are plenty of things that could be changed to improve this code further and I would dive into that but this was more to point out the importance of notes, labels, and understanding hexidecimal and a clever way of using the ascii table to write letters with a bitmap.

Anything wrong, mispelt, done poorly, let me know. Just a "quick" explanation/fix of old code I use to use when I first started to program. Just reminded me how easy it was to just pass up this code as "too advanced" cause I didn't bother to sit down and figure it out.
Final pastebin
Final bitmap

(Wrote this late at night with little sleep, sorry for poor grammar/mistakes)

---

If you would like me to make a bot for you, go here.

capasha

Member

Joined: 2015-02-21

Posts: 4,066

Re: [Tutorial/Explained?] Writing Letters In EE

Isn't this one much better? It would add custom fonts too.

hummerz5

Member

From: wait I'm not a secret mod huh

Joined: 2015-08-10

Posts: 5,853

Re: [Tutorial/Explained?] Writing Letters In EE

My system was similar to that of jaba's. It's useful because we as EE players do have a good idea of what size of font we care to use. It's somewhat more difficult (IMO) to get a regular font down to our 5-px size.

---

thanks HG, HG, HG, HG! anatoly, zumza! zoey!

Hexagon

Member

Joined: 2015-04-22

Posts: 1,213

Re: [Tutorial/Explained?] Writing Letters In EE

Would it be easier just to write the text to an image, crop the image, and just iterate through the pixels sequentially and send those pixels/blocks to EE?

---

???

Joshua708

Member

From: everybodyedits.com

Joined: 2015-03-04

Posts: 153

Re: [Tutorial/Explained?] Writing Letters In EE

Would it be easier just to write the text to an image, crop the image, and just iterate through the pixels sequentially and send those pixels/blocks to EE?

Yes, it would be easier.

offtopic: windows 10 said i have drive errors hope my hard drive isnt dying e.e (It's probably my disk drive which has gone to junk)

---

Hey look a bunch of stats about me

hummerz5

Member

From: wait I'm not a secret mod huh

Joined: 2015-08-10

Posts: 5,853

Re: [Tutorial/Explained?] Writing Letters In EE

Would it be easier just to write the text to an image, crop the image, and just iterate through the pixels sequentially and send those pixels/blocks to EE?

yes, it's easier, but in my experience it also looks better in larger text. We have a noticeably constricted range to work with ,though.

---

thanks HG, HG, HG, HG! anatoly, zumza! zoey!

den3107

Member

From: Netherlands

Joined: 2015-04-24

Posts: 1,025

Re: [Tutorial/Explained?] Writing Letters In EE

Would it be easier just to write the text to an image, crop the image, and just iterate through the pixels sequentially and send those pixels/blocks to EE?

You'd have to go through the trouble of importing all the block colors though (not sure an easy thing you can just download is out yet?).
+ it'd get more complicated when you'd have a certain background. Now if it was a single color it's no problem.
So you'd first have to make an image of the current minimap, write your text on there, and THEN iterate over all the changed pixels.
Or you can just use a font that doesn't have antialiasing...

Also: If you would want to make your own fonts (so not use actual TTF (or other) fonts), you can set the bot up so that the first "letter" will be a configuration part that shows how big each letter is and optionally can also contain antialiasing (by checking for how close each pixel is to white (white = transparent, black = solid, grey colors = semi-transparent) (though then you run into the previous problem again).

Jabatheblob1

Member

Joined: 2015-03-01

Posts: 856

Re: [Tutorial/Explained?] Writing Letters In EE

This tutorial was more to explain the importance of how you write code when other people are looking at it rather than explaining how to write letters in EE. But this does both for you can make your own font by modifying the bitmap. This isn't the best way, all the comments above show, but does teach new programmers the importance of names and comments.

---

If you would like me to make a bot for you, go here.