How To Use /Model?

First Thing if you said /Model Humanoid:Any Numbers

Then You will change your size, Now You Will ask Is there more Models?

Yeah There is Like these [Creeper Model] [Skeleton Model] [Zombie Model] [chibi Model] [More!]

Now If you have any thing you want to say Reply Me!

Good Luck :D

Well i got you! First thing Go to Classicube, Now click on your username and scroll down a little bit until you Something says Change skin

Enjoy!

So... the only tutorial on how to host a mcg server on android is [1] by @megaboi. But the steps they took could be simplified further. Also running on proot is unnecessary. We don't need apps like anlinux just to get the link for a rootfs dl script as there is proot distro. Also there can be ppl who want to just host it for their friends or just want to do random stuff like me. Also Quoting [1], no one is going to join your potato na2 clone anyway.

We will see two ways of running a server.

##requirements: termux, min 700 mb storage and some internet.

Way 1 : The ez way

In this way, we are gonna setup the standalone version of mcg. It's good if you don't want Microsoft flavoured java to stay on your device or want to save some space. No, we won't use the one provided by cc, as it won't work. So, we need to use the one I provide ; Its built for termux.

at first, install git and clone my repo:

apt update && apt install git -y
git clone --depth=1 https://github.com/tbapknoob12mc/standalone-galaxy

now, move to the folder and run the install script:

cd standalone-galaxy
bash install.sh

Then run the server with:

./MCGLinux

If you don't trust the binaries, a build script is provided:

move to the folder and run the build script:

cd standalone-galaxy
bash build.sh install

And run the server.

The problem with this approach is that you can't install plugins. This is for the ones who only wants to build with friends and nothing else.

Way 2 : The normal way

In this way, we will use the mono dependent, official build of mcg. If you think you can run plugins, sorry... Some plugins won't even compile because mono distributed in termux has its limits. This is for the ones who don't mind mono installed. This will take 700 mb storage.

At first, install mono, wget,unzip, libsqlite and then download mcg:

apt update && apt install wget mono-static mono unzip libsqlite -y
wget https://cdn.classicube.net/client/mcg/release/MCGalaxy.zip
unzip MCGalaxy.zip

Now move to the dir and run:

cd MCGalaxy
mono MCGalaxyCLI.exe

Now, if you want someone outside your network to actually join your server,use a port forwarding of tunneling like ngrok,zrok,localhost run or localtunnel which will take a 100 more mb because of nodejs. I use playit gg btw.

If you want any tutorial on administration and management, search on google ok.

If you want to compile mcg from source, you will need proot...but no need of that. Right?

Also I would like to thank megaboi, author of [1].

Again quoting [1], type /blockdb disable [level] to save space.

I hope this helps some1.

Thanks for reading.

Have a nice day :) .

[1]: https://f.classicube.net/topic/931-how-to-host-a-mcgalaxy-server-on-android-not-recommended/

You might want to create a server, and you've also read some tutorials involving the server creation guide, and how to get new players, but what you realize as a major part is, you need custom content. This custom content would mean some unique game mode, or some cool maps that distinct yourself from being a regular free build server. This is where plugins come in.

What are plugins?

Plugins are custom code written by you or someone else, and when loaded, will execute code to modify the server's behavior (which can include, but is not limited to, triggering additional actions upon events being called, registering a new command, registering a new TopStat (/top), modifying what the TabList looks like, etc).

How are they made?

Plugins are .dll files (dynamic-link libraries), aka program extensions that are compiled from source files, which in other words are human-readable text/code. Generally, these source files are written in C#, but there is also options for writing these plugins in other .NET programming languages. The DLL file is produced by a compiler, which could be the built-in server compiler on MCGalaxy (using the /Compile command), your IDE (the code editor), or the dotnet command line tools. In this tutorial, we will be looking at using the server and using Visual Studio 2019 to compile code.

NOTE: MCGalaxy is targeted at .NET framework 4.0, which is an older .NET framework. Meaning, you cannot use newer syntaxes/features unless you re-target MCGalaxy and self-compile the server software, which is strongly not recommended. If you have Visual Studio 2019 Community or Professional installed on your personal computer, and given that you are hosting the server on your personal computer, the server will look and use the compiler from Visual Studio, however.

Now with the two major questions answered, let's get to the process.

Setting up your workspace.

Before we start talking about the code structure of how plugins are written, let's get the software required set up. IDEs (Integrated development environment) are software used to write your code on, you can say they are a more advanced text editor, given we are really just editing plain text files that have a fancy file extension (in this case, the file extension is .cs). The following software are what I recommend for using to write your code on.

1) Visual Studio 2019 (Windows users only)

2) SharpDevelop (Windows users only)

3) MonoDevelop (Linux users only)

4) Visual Studio Code (Cross platform, there's also a web version but it has limited functionalities)

In this tutorial, we will only be using Visual Studio 2019, so unfortunately if you would like to use the other software, you will need to ask someone else for assistance to that software.

How to install Visual Studio 2019:

Unfortunately, Microsoft is a poop head who decided to remove the installation packages for Visual Studio 2019 from their website. So, you will need to source the installer from somewhere else. Chocolatey happens to have sourced the installer to VS 2019, which you can find from this link: https://community.chocolatey.org/packages?q=visual%20studio%202019

You can choose any edition of Visual Studio, because there are already keys online that can be repeatedly used to give you access to any edition. (It's not like Microsoft is trying to make money off the older edition anyways, why do you think they removed it from their website?). I found the keys https://gist.github.com/ansarizafar/7234695e0837c92283144699c3f27532

Chocolatey is a package manager, which is simply software that manages the installations of other software. However, the process to install it is slightly confusing. For our case, we are not setting this up as an organization, and it is assumed that you're using Windows. So, you can open the installation page for Choloatey https://chocolatey.org/install and then select the Individual option. Then, you will open Windows Powershell in Administrator mode, copy and paste the line of code from the website (where it says Set-Execution-Policy) into Powershell, and press enter.

Once Chocolatey installs, navigate back to the Chocolatey package search web page, and copy the command to the edition of Visual Studio you would like to install, and paste that into Windows Powershell, and press enter. After this finishes, you're all good to go!

Installing Git Version Control / GitHub Desktop (optional)

Version control is used to synchronize the copy of the code from your computer to a remote server. This allows for you and other people to collaborate together. The popular options for the remote servers are GitHub and GitLabs.

You can use your IDE's built in Git features, the git command line tools, or GitHub Desktop to synchronize your code. Both the IDE Git features and GitHub Desktop features are very self explanatory and easy to navigate through, so I will save time on explaining that part.

1) We will be creating an account on either GitLab or GitHub first.

2) Once you've verified your email, we are now going to create a repository, which is basically our project.

2a) You might want to make this repository private so no one else besides you and your invited members see the code.

3) Change your working directory to the folder you want to set up your project in (cd [directory]), then use git clone [url] to set up the repository.

3a) You might be asked to authenticate yourself. If you are using GitHub, you can put in your username, but then for the password, you will need to paste in your GitHub API Token, which you can get here: https://github.com/settings/tokens. You should select repo and read:org. Make sure you SAVE THIS TOKEN TO SOMEWHERE SAFE, PREFERABLY YOUR PASSWORD MANAGER. This can allow dangerous people to access your repositories, which is not good.

3b) If you are using GitHub, it is recommended you also install this software, as it will save your time from having to paste in your token each time: https://cli.github.com/. When this is installed, all you need to do is to follow steps 1-2, but you will need to type gh auth login and then type gh repo clone. Read https://cli.github.com/manual/ for how GitHub CLI works.

4) voila! Your repository is set up.

Just a few important commands to remember:

1) git add . - Adds all your changed files

2) git commit -m "your message here" - Creates a commit with "your message here" being the summary of what you've changed. You can think of commits as

3) git push - Sends your commits to the server.

You will run these three commands in order each time you would like to make a change to the Git repository.

PLEASE NOTE ABOUT MERGE CONFLICTS! If someone else updated the code, you will need to make sure their changes do not conflict with what you're syncing to the remote. Read https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/addressing-merge-conflicts/resolving-a-merge-conflict-using-the-command-line for more info.

Creating your solution, and the CSharp project (.csproj)

If you are using MonoDevelop/SharpDevelop/Visual Studio 2019, you will see an option for creating a new project/solution. You will need to click on that, and then give a name to your project, and click "Create".

Then, you'll need to download the MCGalaxy_.dll file, and reference it.

In Visual Studio 2019, you can reference the file by expanding the project, right click References, and click "Add Reference". Then, you'll select the location to the DLL file.

What we are doing here is adding MCGalaxy's main code as a package. This will allow for the IDE to help you with auto-filling methods, and giving hints to the method parameters related to specific parts of the software. It will also allow you to compile the software.

Writing the code

If you do not know how to write code, or if you know how to write code but this is your first time touching C#, that's fine. Please take a look at the below resources available to you:

• https://www.w3schools.com/cs/index.php

• https://www.codecademy.com/learn/learn-c-sharp

• https://essentialcsharp.com/

The fundamental concepts covered in the two websites are very important to what we will be doing.

Starting off with a plugin

We will be creating an example plugin called "NotifyPlayer", which will alert players if our mascot, John ClassiCube has problem with the player because that player has "cubed" too much.

Below is the file "NotifyPlayer.cs":

In the above screenshot, we have done the following:

1) Defined our namespace, JohnClassiCubeLand. Namespaces often times help organize our code, and say if we have a large program/plugin we are making, then the namespace generally stays the same for all files in the program/plugin. You can also section your code to multiple namespaces, e.g. JohnClassiCubeLand.HeIsAngry, for if John ClassiCube is really mad at one of our players, and a part of the plugin (if it's multi-file) decides he wants to chop up the player.

Note that most times, plugins are single-filed. The reason why this is the case is because a) This allows us to reference other plugins, and b) Many smaller plugins/projects can be compiled quickly with the built-in /compile command, which will save our time from having to locate the compiled DLL and then drag and drop it to our server's plugins folder. In this case, the code can have multiple classes in one single file, and/or have regions defined allowing us to collapse/expand different sections of the code.

Example of using regions:

2) We have created the class NotifyPlayer. However, as you see in the screenshot, the class name is underlined red, and on the bottom of the IDE we see there are 3 errors. The reason why this is happening can be explained by the concept of Inheritance.

Inheritance comes into play

The idea of inheritance or metamorphism can be explained by giving you this analogy:

Suppose we are creating a video game and we need to create two objects in the game, a car and a horse. It is agreed that both the car and the horse are vehicles, because they move, but it's just that the way they move are different. Hence, in programming, we can represent both the car and the horse as vehicles, but because the way they move are different, and the noises they make are also different, we need to have a way to define how they function. That is where interfaces and abstract classes come in!

This analogy can be associated to what we are doing. There are many plugins on the server, and while not all of them do the same thing, they all need to register and unregister things upon being loaded and unloaded. Therefore, the Plugin abstract class is created for the management of the plugins, and serves as the parent class of them.

Using Visual Studio, pressing Ctrl + . will bring up a context menu, and clicking Implement abstract class should fill the body of the NotifyPlayer class with the following code:

        public override string name => throw new System.NotImplementedException();

        public override void Load(bool auto)
        {
            throw new System.NotImplementedException();
        }

        public override void Unload(bool auto)
        {
            throw new System.NotImplementedException();
        }

I want you to notice two things:

1) All of these throws exceptions, which we'll replace with what is needed to make the plugin work, and

2) The exceptions all have System. in front of them. The reason why this is happening is because, at least for my file, the using statements were all deleted. In any circumstance, you can choose to include the using statement at the very top of the file, or you can choose to retrieve a method/use anything from a class by typing Namespace.Class instead.

Below is how the above code was fixed.

        public override string name { get { return "NotifyPlayer"; } }
        public override string creator { get { return "75"; } }

        public override void Load(bool auto)
        {

        }

        public override void Unload(bool auto)
        {
            
        }

Explanations to what I've done above:

1) We're using get return because we're overriding a string, and the parent class, Plugin, is expecting a getter method so it can retrieve the name of the plugin. You can also use a fat arrow lambda expression (=>) instead to do the same thing, which would be public override string name => "NotifyPlayer"; Lambdas are complex expressions that are used to create anonymous functions, and that is out of the scope of this guide. You can view more about them here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions. Please do note that lambdas are not compilable via the standard MCGalaxy compilers.

2) I have also overridden the creator property, which allows us to put the author name (sadly it's not John ClassiCube himself). This will mention our name if the plugin fails to load or unload. I also want you to notice this property was not included in by default, as over the years properties like welcome, MCGalaxy_version, Help, and creator have become optional. These are called virtual properties/methods, which can be viewed here: https://github.com/ClassiCube/MCGalaxy/blob/86af8c8f270f9cfb90798890e829de374c9e412a/MCGalaxy/Scripting/Plugin.cs

3) Given that the properties mentioned in (2) are optional/virtual, the property name, and the methods Load and Unload are required/abstract methods, which can be seen from the above link to the Plugin.cs file.

By typing the override keyword however, you will be able to see all available options to override from.

Now, let's start with what we want to do with the plugin. We want to let the player know upon joining the server whether or not that John ClassiCube is mad at them, we want there to be a command for the player to check the reason(s) why John ClassiCube is mad at the player, and give the options for staff member, and even JohnClassiCube himself (who is AndrewPH in disguise, who in reality does not even exist!) to add/delete/view the reason why the player is now on John ClassiCube's not-so-good player list.

Events

I've updated the Load and Unload methods with the following things:

        public override void Load(bool auto)
        {
            OnPlayerConnectEvent.Register(HandlePlayerConnect, Priority.Low);
            Command.Register(new CmdJohnClassiCubeNotifications());
        }

        public override void Unload(bool auto)
        {
            OnPlayerConnectEvent.Unregister(HandlePlayerConnect);
            Command.Unregister(Command.Find("JohnClassiCubeNotifications"));
        }

        private void HandlePlayerConnect(Player p)
        {

        }

I've done the following:

1) I registered the OnPlayerConnectEvent. Different events, and what they do are all outlined in MCGalaxy's events folder: https://github.com/ClassiCube/MCGalaxy/tree/86af8c8f270f9cfb90798890e829de374c9e412a/MCGalaxy/Events

These events allow you to perform an action when a player performs certain action, for example, running a command, sending a chat message, moving, joining another level. Hooking into events would allow you to do a certain action based on what is provided to you. In our case, we will be notifying the player of them having a notification from John ClassiCube.

2) We've registered and unregistered a Command class that we will be making soon. Registering a command is simple, all we are doing is passing a newly instantiated command to the Register method. Unregistering the command though will require us to find the loaded instance first.

For this bit, I will need to give you one note: Do NOT unregister new CmdJohnClassiCubeNotifications(); This will not work because Unregister acts like removing items from a list. This newly instantiated object is not the same as the one we registered before! One way to avoid using Command.Find is to store CmdJohnClassiCubeNotifications into a static variable, and unregister that variable instead.

Storing user's data

Because we need to store the player's notifications, we will need some way to write each player's notifications into the server files. Thankfully, with MCGalaxy, we are given a built in feature, namely PlayerExtList and also PlayerList. These two classes allows us to retrieve data from a text file.

• PlayerList stores player names into a text file, with each line having one player. You can use Contains, Add, Remove to manipulate the data. Each time Add or Remove is called, you must call the Save method so it can update the data to the text file, if not it will be stored only temporarily in memory.

• PlayerExtList stores player names and some corresponding data into a text file, with each line being the player's name, followed by a space, and some data. You can use Contains, Update, Get, Remove to manipulate the data. Each time Update or Remove is called, you must call the Save method so it can update the data to the text file, if not it will be stored only temporarily in memory.

TL;DR PlayerList retrieves data from a text file and creates a temporary List to store the data, and allows you to do read/write to the list, and you need to call Save() each time for the data to be updated to the text file.

PlayerList retrieves data from a text file and creates a temporary Dictionary to store the data, and allows you to do read/write to the Key-value pairs, and you need to c all Save() each time for the data to be updated to the text file.

So, now we will be setting up a PlayerExtList to store each player's notifications.

    public class NotifyPlayer : Plugin
    {
        public override string name { get { return "NotifyPlayer"; } }
        public override string creator { get { return "75"; } }

        public const string PATH = "plugins/NotifyPlayer/";
        public const string PATH_NOTIFICATIONS = PATH + "notifications.txt";
        public static PlayerExtList notificationsList;

        public override void Load(bool auto)
        {
            notificationsList = PlayerExtList.Load(PATH_NOTIFICATIONS);

            OnPlayerConnectEvent.Register(HandlePlayerConnect, Priority.Low);
            Command.Register(new CmdJohnClassiCubeNotifications());
        }

        public override void Unload(bool auto)
        {
            OnPlayerConnectEvent.Unregister(HandlePlayerConnect);
            Command.Unregister(Command.Find("JohnClassiCubeNotifications"));
        }

        private void HandlePlayerConnect(Player p)
        {
            string data = notificationsList.Get(p.name);
            if (!string.IsNullOrEmpty(data))
                p.Message("You have &e{0}&S notifications from John ClassiCube. &WView it immediately, or else. &T/jccn", data.Split(',').Length);
        }
    }

WOW! That was a lot of changes. I will take some time to explain to you what each line does.

• We've created two constant variables. Constant variables are read-only, compile time variables that store data that can only be read and not modifiable during run time, and does not require a object reference (meaning it's basically static!). These two variables are the paths to our plugin's folder, and the notifications text file to store data

• I added a public static PlayerExtList which stores player notifications. It is public static because it needs to be accessible outside of the class without being instantiated in an object.

• I added one line before registering the OnPlayerConnectEvent handler, which is PlayerExtList.Load. This will retrieve the data and load it into memory, or if the text file does not exist, it will create a new empty text file and instantiate an empty list of Key-value pairs.

• I updated the body of HandlePlayerConnect, and it will now check for if a player has notifications and alert the player upon connect to view the notifications. We're using a extension method from MCGalaxy, namely Split, to split the string by chopping it by where there is a comma (,), and then getting the number of items there are. The notifications in the text file would then look like this:

75+ Notification1,Notification2,Notification3

Custom Command

Now it's the time to create our command!

    public class CmdJohnClassiCubeNotifications : Command2
    {
        public override string name { get { return "JohnClassiCubeNotifications"; } }
        public override string shortcut { get { return "jccn"; } }
        public override CommandPerm[] ExtraPerms
        {
            get
            {
                return new[] { new CommandPerm(LevelPermission.Operator, "can set and view all players' notifications") };
            }
        }
        public override string type { get { return CommandTypes.Information; } }

        public string[] GetNotifications(string player)
        {
            string data = NotifyPlayer.notificationsList.Get(player);

            if (string.IsNullOrEmpty(player)) return null;
            else return data.Split(',');
        }

        public void NotificationPrinter(Player p, string notification)
        {
            p.Message("- &f" + notification);
        }

        public override void Use(Player p, string message, CommandData data)
        {
            string[] args = message.SplitSpaces(3);

            if (args[0].CaselessEq("add"))
            {
                if (!CheckExtraPerm(p, data, 1)) return;

                if (3 > args.Length) { p.Message("You need more parameters."); return; }

                string matched = PlayerInfo.FindMatchesPreferOnline(p, args[1]);
                if (string.IsNullOrEmpty(matched)) return;

                List<string> notifications = new List<string>(GetNotifications(matched));
                notifications.Add(args[2]);
                NotifyPlayer.notificationsList.Update(matched, notifications.Join(","));
                NotifyPlayer.notificationsList.Save();
                p.Message("Notification was added.");
            } 
            else if (args[0].CaselessEq("del"))
            {
                if (!CheckExtraPerm(p, data, 1)) return;

                if (3 > args.Length) { p.Message("You need more parameters."); return; }

                string matched = PlayerInfo.FindMatchesPreferOnline(p, args[1]);
                if (string.IsNullOrEmpty(matched)) return;

                List<string> notifications = new List<string>(GetNotifications(matched));
                string notification = Matcher.Find(p, args[2], out int matches,
                    notifications, null, null, "notification");
                bool removed = false;
                if (notification != null)
                {
                    notifications.Remove(notification);
                    NotifyPlayer.notificationsList.Update(matched, notifications.Join(","));
                    NotifyPlayer.notificationsList.Save();
                    removed = true;
                }

                p.Message("{0} rmoved the notification from {1}.", removed ? "&aSuccessfully" : "&cCould not", p.FormatNick(matched));
            }
            else
            {
                //elvis operator
                string player = message.Length == 0 ? p.name : PlayerInfo.FindMatchesPreferOnline(p, message);
                if (string.IsNullOrEmpty(player)) return;

                if (player != p.name && !CheckExtraPerm(p, data, 1)) return;

                string[] items = GetNotifications(player);
                Paginator.Output(p, items, (p_, notification) => NotificationPrinter(p_, notification),
                    "JohnClassiCubeNotifications " + player, "notifications", args.Length > 2 ? args[1] : "");
            }
        }

        public override void Help(Player p)
        {
            p.Message("&T/JohnClassiCubeNotifications <player>");
            p.Message("&HViews the notifications that you or another player has from John ClassiCube.");
            p.Message("&T/JohnClassiCubeNotifications add [player] [notification]");
            p.Message("&HAdds a notification to the player");
            p.Message("&T/JohnClassiCubeNotifications del [player] [notification]");
            p.Message("&HDeletes a notification from the player");
        }
    }

WOAH! That's so much more stuff to take in. You might be asking, what is all this?

Well, let's sort this all through one by one.

A. General structure of the code

All commands generally will follow the same class header, with it being Cmd[name] : Command or Cmd[name] : Command2. When I say generally, I mean it because there are abstract classes that inherit either Command or Command2, and does something specific. This can be seen with the example of EntityPropertyCmd and RoundsGameCmd, where one is used for changing properties of a bot or a player (e.g. skins and models), or RoundsGameCmd where the command inherits this for unified functionality as a RoundsGame game mode command.

The general differences between Command and Command2 is this:

• Command requires you to override name, type, Use(Player p, string message), and Help(p).

• Command2 requires you to override name, type, and Help(p), with Use(Player p, string message) being optional, and also allows you to override another optional overload of Use, being Use(Player p, string message, CommandData data). The CommandData object passed provides information about where the command is ran, the coordinates of the Message Block if available, and the rank that the player ran as (in which, we don't check for the rank of the player because the player could be running the command via /sendcmd and extra permissions needs to be bypassed).

We're using Command2 because we need to check for extra command permissions using the method CheckExtraPerms to check if the player has staff permissions to manipulate player data.

As said earlier, typing just the override keyword will show up the properties and methods you are allowed to override...

• Help(Player p, string message) is an overridable method for providing additional information for the command if they player types /help command <args>, where the message parameter is <args>

• most others are self explanatory, so I will just leave it at that

B. The Body of the Use Method, and the two helper methods

The string.SplitSpaces extension method is also a feature that comes from MCGalaxy. This method allows us to split a string into a string array by chopping it up by where there is a space. It also has an overload to limit the maximum of items we can have in that array. In this case as we specified 3 as the parameter, the method will chop at space A, and space B, and then leave the rest as the 3rd item.

Then, we use args[0].CaselessEq(...) to check for if the string caseless equals a certain subcomand. In which, CaselessEq is also a built in method. There is also CaselessStarts, CaselessEnds, CaselessContains for strings. CaselessContains is also available for enumerable lists.

We use PlayerInfo.FindMatchesPreferOnline(Player p, string name), which is a built in MCGalaxy method to find the exact name of a player as it is stored in the server database so to find the data matching the exact name of the player, and this method returns null if no players of the name is found, which is why we return when that is the case. You can simply check if it equals null, but I just prefer using string.IsNullOrEmpty because it sounds very fancy.

...and that's mostly it

Wrap up

That's it! You can view the full code here: https://gist.github.com/SpicyCombo/a9034c4912d82b082378aa08a789e2f2

Now of course, that was not everything. There may be a comment or a follow up post either by me, or some other community in the community. For other developers, a few other topics you can talk about are:

• //reference and //pluginref, the usage of external libraries and referencing other plugins

• Manipulating the Database

• Registering/Unregistering TopStat (which is easy, someone can just post the links down to an example)

• Custom events (which Venk has done, and I've done so as well.. idk If I'd like to share it though)

Other Tidbits

1) Reading the GitHub MCGalaxy wiki, and expanding the section "Technical info (for developers)" will provide information on commands to compile and load the plugin using the built-in compiler, and API changes/breakages: https://github.com/ClassiCube/MCGalaxy/wiki/Scripting. You should check here if you see something built in not working, and you need to fix it.

2) If you are using Visual Studio 2019, it's recommended to use the hotkey Ctrl + Shift + S every now and then to save all files in your project. This will avoid surprises if your computer suddenly loses power, this is so your changes are saved before anything out of ordinary happens.

Final words

With anything in life, the more effort you put into something, the more you will get out of it. If you ever get stuck writing code, or need some concept explained to you, feel free to ask someone in the community for help. The forums, ClassiCube Discord, server owners/developers will be here when you need it. With all that being said, I wish you all, the readers the best of luck, and hope your next project will succeed (with a lot of glory).

:D

75 is your Helpful Coding Assistant (HCA)

[transmission ended]

BetaCraft V1 heartbeat has been nonfunctional for a long while and will be sunset on October 1st 2024. You can view the new instructions for setting up the heartbeat here. You however still have to configure the auth service for ClassiCube to avoid username conflicts.

This tutorial shows you how to set up a server running MCGalaxy 1.9.3.5+ to allow players to connect from BetaCraft, or other services.

Step 1. Open up server.properties inside the properties folder, and under "Other settings" you should find a variable called "HeartbeatURL".

Step 2. Change HeartbeatURL to

http://www.classicube.net/heartbeat.jsp,https://betacraft.uk/heartbeat.jsp

After doing that, the following area should look like this.

Step 3. Save the file, and do /server reload to generate the necessary configuration.

Step 4 (MCGalaxy 1.9.3.6+). Open up authservices.properties inside the properties folder, and look for a line that says

URL = http://www.classicube.net/heartbeat.jsp

Under it change

name-suffix =

to

name-suffix = +

And under

URL = https://betacraft.uk/heartbeat.jsp

change

skin-prefix = 

to

skin-prefix = https://minotar.net/skin/

(MCGalaxy 1.9.4.8+) along side changing

mojang-auth = false

to

mojang-auth = true

The file should now look like this.

Doing these changes allows the server to know and properly store player info for each player on each authentication service, and allows ClassiCube players to see Minecraft player skins.

Step 5. Save the file and do /server reload, and wait for a while.

Step 6. Check both of the server lists if your server is listed.

Step 7. Join the server using the same username on both BetaCraft and ClassiCube to see if everything works.

So recently some people asked me (And the other too) On how to make a texture pack, please note that making texture packs can take some time but it can be also used to make awesome designs! In that case, this tutorial will show you how to make a great texture pack!

1. Basics

Firstly to make a texture pack you will need a drawing application that supports transparent, let's say for example (paint-net).

Secondly you will need to have the default zip file and to get that you will need to go to the texpack folder and find default.zip. Copy and paste the zip somewhere and extract it, there you can change the texture pack, however since this is a block texture pack tutorial, we will focus on terrain.png to make our new blocks.

2. Creating block textures

Open paint-net and click on the "File" button on the top corner, then select Open and select the terrain.png then you can add new blocks or change the blocks!

Note: (All the blocks on terrain.png are 16x16, if you try to add a block higher than 16x16, let's say maybe 20x20 then you probably have to resize it.)

3. Testing your texture pack

Once you have finished making your texture pack, drop the terrain.png to the zip file, you can also rename the zip file. (If it tells you that there is already a terrain.png inside the zip, click replace.)

After that, put your .zip texture pack to the texpacks folder, then run ClassiCube, hop on a singleplayer world or a multiplayer, go to the Game menu and click Choose texture pack, then select your texture pack and it will instantly change the texture pack to yours!

4. Making your texture pack public for everyone!

This step is very simple, all you need is Dropbox or any other app, drop your .zip file to there, then wait till it finishes uploading, then copy the link that it gave you, after that hop on a multiplayer world, go to your Overseer world and type /os map texture and paste the link, then hit enter, it will tell you to download the texture pack, click Yes or Always Yes, then you will see your texture pack in your Overseer map, and everyone can see your texture pack in your Overseer map too (Only if they click the Yes button) 

I hope you all enjoyed this tutorial, goodbye and have a lovely day!

You must have server file access to both servers to accomplish this.

In order to fully move mylevel to another server you will need:

For blocks and zones,
    mylevel.lvl file in `levels`
    
For blockdefs (custom blocks),
    if the level only uses local blocks and does not use any globally defined blocks:
        lvl_mylevel.json in `blockdefs`
    if the level only uses global blocks:
        Clone global.json from `blockdefs` and rename it to lvl_mylevel.json before cloning the file to the other server
    if the level uses both global and local blocks:
        use ClassiCube to save the level as temp.cw, import it into a server (/help import), then grab lvl_temp.json and rename it to lvl_mylevel.json before cloning that file to the other server
        this servers the purpose of combining local and global blocks into one blockdef file
    
For blockprops (slab stacking and etc),
    _mylevel.txt in `blockprops`
    
For message blocks,
    1. Extract the messages from the server database with /server backup table Messagesmylevel
    2. Messagesmylevel.sql will now be in the root folder of your server. Bring this file to the root folder in the other server.
    3. In the other server, use /server import Messagesmylevel
For Portals,
    Repeat the steps for message blocks, but instead of "Messagesmylevel" use "Portalsmylevel"
For bots,
    extra/bots/mylevel.json
    
For all the remaining level properties (env, settings from /map, etc),
    mylevel.properties in `levels/level properties`
   

This is really simple. 

(1 Add mini-games, fun and more. 

(2 Be kind and don't break your own server rules

(3 Protect server 

(4 Make a discord server about it and be active

(5 Gain player's trust and make them staff.

(6 Listen and respect your community.

(7 Link your server to betacraft, (if you want a mini game, add classic games like lava survival, countdown, etc.)

(8 Freebuild, themed builds

(9 Version supports

(10 Don't admin abuse.

Hope it helps. It's like easy stuff man!

Heya everyone, this guide will make you learn how to improve your buildings!

1. Basics

There are 65 unique blocks in the game, many including stone, etc. To open up your inventory, press "B" on the keyboard, if you are on mobile, you should find three dots on your hotbar, tap on it to open the inventory, here will show you all the blocks you can use.

2. Texture packs

There are many Texture packs made by people, which can help you make a design, decorations, etc. These texture packs can be found on servers and websites, if you want to put the texture pack into your Overseer (which can be done by /os map create) Then type /mi env in the world that has a texture pack, and copy the link, go to your Overseer by typing /os go, then type /os map texture (URL), if the texture pack has a .png, it will only copy the terrain texture, if it is a .zip, it will copy the texture pack. If you want to see the terrain, press F10

3. Creating new blocks

custom blocks allow you to make new blocks, edit them, and much more! Let's see how to make one. first, you need to type /os lb add, this will ask you questions about what your block name wants to be, etc. To answer any of those questions, say /os lb answer [answer], and if you want to cancel, just simply type /os lb abort, now if you made a mistake you can revert it by doing /os lb revert.

Once you have made your block, you have done it! You made a block, however, if you want to edit it at any time, you can do /os lb edit [ID] [property] [value].

4. Buildings

When you are making a build, you can mess it up at any time, and sometimes it would look bad, Here are some tips that can help you improve it!

Ideas. Make sure to have an idea for your buildings (e.g a house, hospital, gas station). This might improve your buildings if you have no idea what you are doing.

Inspiration. You can get some inspiration from people, and the internet and this will improve your buildings.

Patient. I know this might be a little funny, but I'm serious, being patient helps a lot in buildings.

And that's it, a simple guide that helps your buildings, if you want a version showcasing everything about Custom blocks, I highly recommend watching Bruceja's building tutorial. You can watch it here at https://www.youtube.com/watch?v=DG9JgmdiJ-k, anyways good luck and have a nice day!!

I have recently made a full in depth custom block guide for ClassiCube. People have asked for it and it's finally here, enjoy:

https://www.youtube.com/watch?v=DG9JgmdiJ-k

2. type /os map add

3. type /goto "insert user"+"if maps created"

And Your Done!!!!!

PS : its a tutorial for noobs who doesnt now how to create maps dont take it seriously

Requirements:

- Copy paste knowledge

- Acces to classicube files

- A program to open .zip files

- paint.net  or gimp (Don't use Microsoft paint /3D or the transparency will be gone from the entire image) 

- A classicube server with /gb or /lb and textures (in my case I use MCGalaxy)

Step 1: Creating the texture

First, you need to get the textures to be able to modify them.

Go to the folder where all your classicube files are. There try to find a folder named: 

In there is a file named: 

Copy the file and paste it into your desktop or anywhere else that is not in the classicube files.

Open with the program you use to open .zip file. 

There, try to find and extract the file from .

Open and start editing.

 To create a new texture replace  with the texture/textures you will add                                                                                                                                                                                                   (If you will add an animation read  to understand how to add animations work)

After adding the texture save the changes and takeagain inside in and upload  to google drive or anything else

Step 2: Enable the textures

Go to you server's files

In your server's files go to and in the folder find 

Open the file and find: 

Set the url with the url of the place you uploaded  

Start the server and join your server

Step 3: Block creation

The server will ask you if you want to use their textures. If not, press F10 to check if the textures are enabled 

To add the block in a specific level use /lb.

To add the block in the entire the server use /gb

then use

/gb add

then  /gb (name of the block)

then /gb 0 if it is a solid block like stone or type /gb 1 if its a sprite like flowers

It will ask for textures of the block. To know wich texture is wich press F10. Each one has its own texture id 

 EXAMPLE: The bedrock texture has an ID of 17

The other things /gb will explain to you

Reply to this if you need help

Now, click settings in the upper right corner. Change your server name. now visit all of the tabs and once your done editing them, go back to he first tab. Now below your server's name, click Port forward. Now you should follow what it said because I never got to that point. Now your server should be ready!

Your friendly neighborhood noob 
Tet

here is my map: http://www.mediafire.com/file/x8r3aa0yb7swoue/nothing_in_existince_except_water_brick_bedrock_steve_air.cw/file

This tutorial is still valid, however, and you can still use IRC if you wish.

Hello!

In this tutorial, I will be showing you how to set up a bridge between a ClassiCube server, IRC, Discord and back.

Prerequisites:

• A server running software which supports IRC (MCGalaxy is the most common one)
• A computer which has a terminal prompt and supports Node.js/npm (this is unlikely, but possible to work on chromebooks)
• A Discord account (so you can create the bot)
• A brain

1. Set up IRC on your ClassiCube server

On MCGalaxy, this is somewhere in properties/server.properties. Just enable IRC, keep the server and port as they are, don't put anything in OP channel and put whatever you want for channel. (Make sure that it starts with # though). I'll use #example for this tutorial.

2. Install npm (what is npm?)

On Linux, you can use your package manager of choice to install npm. Examples:

Ubuntu (and other Debian-based distros)

sudo apt install npm

Arch:

sudo pacman -S npm

Note: you may need to additionally install Node.js as well, haven't tried it myself.

On Windows and macOS, you will have to download and install it from Node.js's download page. It is recommended that you use the LTS version, but "Current" works as well.

3. Create a configuration file for discord-irc

Go to a new directory which you'll use for your bot and create a new .json file. Here is what you'll put in it (explanations for the numbers will be given below):

 {
    "nickname": "1",
    "server": "2",
    "discordToken": "3",
    "channelMapping": {
      "4": "5"
    }
  }

1 - Replace this with the nickname of the bot. This will be seen in-game and from the IRC channel. It is recommended that you just set this to "Discord".

2 - Replace this with the IRC server you're using. MCGalaxy uses "irc.esper.net" by default.

3 - Replace this with your Discord bot's token (NEVER SHARE IT WITH ANYONE ELSE!). More instructions in step 4.

4 - Replace this with the Discord channel's ID. Essentially, all messages will be sent in that channel. To get a channel's ID, right-click it and click "Copy ID". If you don't see this, enable Developer Mode from the Advanced section of the Discord settings.

5 - Replace this with the IRC channel's name. If you set your MCGalaxy server's IRC channel to #example, put #example there.

Note: you can expand this file with more options if you want. This is just the very minimal version.

4. Create a new Discord bot and get its token

Creating a Discord bot is easy, you just have to go to My Applications on the Discord Developer Portal, create a new application, then create a bot for it. Once that is done, click the button to copy the token and insert it into the json file you made above. Once again, do NOT share your token with anyone, ever.

5. Install discord-irc and run the bot

Open a terminal prompt (cmd.exe or powershell works on Windows) and cd to the directory in which the .json file is located, then install discord-irc using npm by writing this:

npm i -g discord-irc

and pressing Enter/Return. After this, wait until it's installed. If it doesn't let you install it, try putting sudo before npm. (so sudo npm i -g discord-irc). This will give you root permissions and works only on Linux, you will also need to input your user password.

Once discord-irc is installed, make sure that you are in the .json file's directory and run this from the terminal:

discord-irc --config <name>.json

The bot should be running and should be relaying messages to/from the IRC, which by itself is connected to the ClassiCube server. To stop the bot, press Ctrl+C.

You can also run discord-irc from different directories, just use --config /path/to/<name>.json as the arguments.

That's it!

If you have any questions, extra tips or have anything to say about this, please let me know. Have a nice day and I hope this helps you!

~Alex

* Welcome to the MCGalaxy guide. Before reading onward, please do note that this guide is initially made for MCGalaxy version 1.9.0.6, as such, some of the things stated below may not work in either past versions. If not, tell me and I will update it. *

Starting the server

Starting the server and actually making it so it's online is the most crucial thing you're going to need to do in this guide. Everything else will be informative and/or optional.

To start the server, make sure you download your release from here, keeping in-mind I will be using 1.9.0.6 to explain things. Once downloaded, you will need to extract the contents into a folder somewhere.

Once complete, you will then need to run either MCGalaxy.exe or MCGalaxyCLI.exe. This will open up a GUI/CLI menu allowing you to edit the server.

Next, you will need to port forward. If your router does not support UPnP portforwarding, you can find a guide on how to port forward here. If it does support UPnP port-forwarding then proceed to read on further. Upon opening the GUI, click the properties button. A menu like this should open (yours will likely be different):

Next, you will need to enter a port in the port box (or keep it as 25565) and then click Server Port Utilities. Another GUI menu should pop up, here you will need to enter the previous port number into the box and then click Forward. If the forward was successful, you will receive a green Ports forwarded successfully using UPnP message. If not, then you will need to port forward manually by visiting the link above.

Once you've done that, click out of that and press Save to save your progress. Voilà! Your server is ready to play. It should be around the bottom area of the server list, if it isn't try refreshing.

Configuring your server

Editing server properties is probably the most fun part of starting a server, you have full access to features and you can toggle things you want enabled/disabled on the server. To do this, you need to open up that folder we were talking about earlier and navigate to the /properties folder. In here there will be 8 files that you can edit customize. You can also edit things from the GUI, but this gives you a bit more options to choose from.

The only one you really need to check out is server.properties, if you've never edited a .properties file, you can open it in any text editing program. A guide is already waiting for you inside the file.

A great way to display information is via the use of text files. You can modify the text files by going to the /text folder. Here you can edit things like the server welcome message, rules, news etc. All files can be opened via text editing software as well.

Using the console

The console is used as a way of executing commands without having to be in-game. It also bypasses permissions so you can use any command from any rank with ease, though keep in mind, some commands purposely disable use from the console. Using commands is similar to in-game, which uses /[command]. If a / or ! isn't present at the start, it will be treated as a chat message.

You should probably give yourself the superop or nobody rank to get full control of the server. See below for more information on assigning ranks.

Ranks

Ranks are the assortment of players into hierarchical groups. To modify ranks, you will need to open the properties menu and then click on Ranks. Here you will be able to edit permission levels and colours etc.

To rank a player to a specific rank, you will need to use /rank [username] [rank]. This will give them access to all the commands and permissions the specified rank has.

Commands and Permissions

Commands are a great way of doing things in-game, but if everyone has the same permissions, the server could be come anarchic quite fast. One of the commands you will need to become familiar with is /cmdset which is the nobody rank by default. Using your console knowledge from before, typing /cmdset cmdset [rank name] will allow the rank of your choice and above to execute it from in-game. You can either keep the permissions as is (not recommended) or you can modify the permissions to your choosing.

You can allow specific ranks to use a command by using /cmdset [command] +[rank name], this will allow the rank to use the command even if they are not above the default command rank. You can also do /cmdset [command] -[rank name] to prevent a specific rank from using the command. And lastly for setting command permissions is /cmdset [command] [rank name] [extra permission number] which will allow the rank specified and above to be able to use the command's extra permission.

A full list of commands can be found via /commands all all and each are colour-coded to their respective rank colours. Information can be found for each command using /help [command].

Levels (or worlds/realms/maps)

Levels are a world that players can visit/build on. By default the main level will be called main, but you can change that later by doing /main [level].

Most MCGalaxy servers support overseer levels which allow players to have their own private world that only they can build in. To allow this, just set the /overseer command to the lowest rank you want to be able to use the command. This will allow people to use /os map add and /os go as well as other overseer commands.

To create a new level that isn't a realm world, you can type /newlvl create [map name] <width> <height> <length> <theme> <seed> (the ones in angled brackets are optional).

If you're unhappy with the map size, you can change the size via /resizelvl [map name] [new width] [new height] [new length]. Keeping in mind, that decreasing a level size may remove blocks.

Levels can be renamed via /renamelvl [map name] [new map name] and can be deleted via /deletelvl [map name].

Conclusion
There you have it, you now know everything you need to about setting up your very own MCGalaxy server.

Something not making sense? Still confused about something? I'm usually around the community and am quite happy to help. You can find me on Discord via @Venk#2020 or on ByteIRC via #PuissantRoyale.

epic kickflip dos: you can switch between the default theme and an experimental dark theme at the bottom of every page

post more sick kickflips here and maybe i'll add them to the list

Stop 2: Click the icon on chrome with 3 dots on up right corner

Step 3: Click more tools

Step 4: Click create shortcut

Step 5: Set a name as what ever you want to 

Step 6: Click Create

Now on your desktop it will be a Icon with CC logo that means you have made a shortcut on your desktop

Ups when i was making a arrow for step 4 and 5 i pointed it to "save page as" that a mastake r+that i made click the other one create shortcut

First look in the internet and look for a reference of an Medieval house,

My reference for today:

Now you have a reference. GREAT!

Quick tip: When building by an reference you want to plan out where you are building? how big is it going to be?

This part is the most trickiest

Next, do the blueprints of your reference 

Example:

ps: this is not my build, if u want to see my builds go on furiousfiregirl+ 2 or 3 in N2a or go in furiousfiregirl+ in police sever

You dont want to start by just building the house well the outside of it and not to think of the inside of the house or else it would get tickier than it already is.

Next start build the whole house, add the block u think should be at, and if the sever doesn't have the blocks you need that competently fine just change it up a bit.

(i dont have an example screenshots were a bit to big)

Once your done, do the inside, try to do those little details bc they will make a difference.

BOOM your done u have a Medieval house.

This tutorial is not only just Medieval houses this can be used in all builds you want to do.

This doesnt help srry, not much I can do the screenshots were to big.

-Furious