gehörst leider trotzdem zum team und bist auch aktiv im thread vertretenebenfalls reagierst du auf dinge der community.
dein auftreten zeigt nur, dass das hotel nichts werden kann. wird am ende eh jeder gebannt der dir nicht passt.
Jaa ok dann geh wieder in deine Vault und schreis da herum. Weißte alle aus Retros etc sind auch auf RT haha Palme
lang nicht so einen professionellen admin gesehen
Wo steht das ich Admin bin du Horst; Ich bin Programmierer/Entwickler & habe allgemein nichts mit dem Umfeld der Benutzer zutun. Schon gar nicht mit so Affen.
Gratulation, wohl das minderbemittelteste Team seit langem, daher setzt es einen Dislike, da aus diesem Projekt nichts werden wird, davon bin ich überzeugt. Wenigstens habt ihr dabei anscheinend noch viele neue Dinge gelernt, wenn es auch für uns keinen Nutzen haben wird, so habt ihr wenigstens was gelernt.
Deine Visage muss auch ziemlich minderbemittelt sein & kannst Stolz darauf sein - Da sich aus dir nie was entwickeln wird.
#NoHatersWelcome
Große Worte, bin mal gespannt was daraus wird und ob das Projekt überhaupt online kommt
Klar; Wenn du Fortschritte seitens meiner sehen möchtest (Gamserver ist intern); ein kleiner CLI-Ausschnitt:
Mit HTML-Template
Ihr arbeitet mittlerweile knapp 4 Monate am Hotel? Was macht ihr denn solange?
In dem Projekt geht es uns, den Programmierern, eigentlich nur um das Erweitern des Wissens & das Ergebnis darin.
Dem Management geht es darum, dass durch das gute Ergebnis Spieler aus einem Schrott Hotel wie https://retrotown.ws/www.Habbo.st, https://retrotown.ws/www.Hubba.cc, https://retrotown.ws/www.Jabbo.cc sie sich zurückziehen & in einem Hotel (unseres) mit mehr Möglichkeiten spaß haben können - Abgesehen dass das Management auch noch die Aufmerksamkeit im Internet bekommt, die die sie schon immer wollte.
Das beste an solch einem selbst geschriebenen Gameserver ist, dass das Updaten viel einfacher ablaufen kann 
Patches, Feature updates, ... Ist ein riesen Development dass aber Spaß macht
Vor 2016 wird es sowieso nichts seitens des Gameservers geben. UND ´Nein, wir benutzen für den Client kein ActionScript :')
Darunter Planen wir noch, ob wir den Gameserver nicht doch lieber als ISO-Image zum Virtualisieren verwendbar machen wollen; Weshalb? Windows benutzt schon mindestens 1500 Threads & 40000 Handles - Durch den Gameserver würden die Handles & Threads sich vermehren, was wiederrum zu Schaden führen könne - Da too many threads dauerhaft für den Server verletzend sein können. Ja, es ist nur Habbo - Aber ist doch egal! Wer spaß darin hat kann ja seinen Spaß daran haben
Der jetzige Stand des Gameserver ist noch in 'plain C/C++' (unmanaged code) geschrieben - Was zu verdammt vielen Vorteilen schaft aber auch zu NUR EINEM Nachteil: Bibliotheken;
Wir benutzen zwei externe Bibliotheken bis jetzt: Chilkat & rapidxml (Http & XML support => Für kommerzielle Nutzung (Patches, Updates)).
Also, Geduld ~
PS: Das Development des Gameservers ist zur Zeit pausiert, da der Client fehlt - Daran wird bereits von einem anderen Team (Das seitens mir und einem Freund gehört) getüftelt.
Vor hackern sich zu schützen, ... Geht 100%.
Da meistens der Fehler im Code liegt; Du musst eben schauen wo du einen Filter einbauen könntest, sichergehen das die Software die du benutzt ebenso sicher ist.
Vor DDoS-Attacken kannst du dich nicht vollkommend Absichern wenn du einen Server gemietet hast, aber Anfragen ausfiltern kannst du.
Hast du einen Server daheim, dann schau dir die Netzwerkkarte an. Das wichtigste ist immer die Netzwerkkarte/Anbindung.
Du musst die Inputs einlesen & teilen, Silbensysteme etc. Vergleichen! Am besten per Dateisystem (Ist leichter zum teilen).
Webseiten benutzen Kopfdaten (<meta>), musst halt hinsitzen und dafür sorgen die Meta-Daten abfangen zu können, aussortieren und einteilen.
Ich habe kein Plan wie man da Anfangen sollte in der ersten Zeile, aber wie es halt funktioniert & mit sicherheit beginnt solch ein Skript nicht mit '<?php ?>' 
noch '#'.
Wenn du schnelle Resultate willst, musst du per 'Rhythmus' arbeiten, Daten komprimieren & alles mögliche drum & dran. IP/MAC speichern, den Benutzer kennenlernen für Vorschläge & sooo vieles merken.
Du musst auch die Rechte von Staaten außerhalb einhalten; Also lass das; Wenn du es seriös meinst wärst du auf StackOverflow. Also jo programmier aus Spaß
Saubere Erklärung! 7/10, da man PHP heute nicht mehr bevorzugen sollte;
Die Zukunft liegt in den Händen von Python & Erlang.
Ich persönlich benutze CLI, C/C++ Language Interface for Web für den BigStorageHTTP Webserver (BSHW) von mir entwickelt für ein kommendes Projekt - Da PHP nicht unsere Anforderungen erfüllt.
Wer CLI kennenlernen möchte, hier Links:
Das Hotel befindet sich der Zeit noch in der Aufbau-Phase. Vorschläge sind natürlich nicht auszuschließen! Jeden Tag wird darüber diskutiert was man besser machen, oder gar ganz verändern könne. Wir arbeiten mit einem dynamischen, gut strukturierten - in C/C++ selbst geschrieben Habboserver, der uns schnelles Patching ermöglicht.
Ich möchte dazu Habboserver sagen, da dieser einem "Emulator" gar nicht ähnelt - Noch irgendetwas emuliert.
Der Schwerpunkt eines Programmierers liegt darin, Leuten mit dem Endprodukt Spaß zu ermöglichen, Probleme so schnellst wie möglich zu beheben.
Zeit ist Wertvoll, die Lebenserwartung von uns liegt bereits schon über den 100 Jahren, deswegen - Zeit in solch einem Projekt zu investieren ist ein tolles Gefühl!
Ich selbst stand neulich vor dem rießen Problem "return"-Werte der Web-Anfrage abzufangen, es machte mir rießen Spaß mein Wissen zu erweitern und dieses Problem
beiseite zu schaffen - Man muss bedenken, wir benutzen systemeigenes C & C++. Grips & Tricks sind gefragt!
Von einer Umschreibung, dass sich R63A & R63B Benutzer im selben Client treffen können, ist nicht auszuschließen - Wie dies aussehen solle wird auf jeden Fall noch besprochen.
Darunter wollen wir gebannten Spielern auch noch eine Gelegenheit geben sich "Sozial Integrieren" zu können über einer "Dunce-Session". - Für einige GTA Spieler kommt es ziemlich bekannt vor - Wird jedoch nicht so übernommen wie in Grand Theft Auto. -
Bei dieser Dunce-Session wird noch debattiert;
Bei irgendwelchen extra-Wünschen oder Erwartungen ~ Lasst es uns wissen!
Hey, zuerst einmal musst du, wie oben schon genannt, die Programmiersprache die Dir gefällt oder dazu geeignet ist aussuchen.
Du musst Fähigkeiten erfüllen wie Erfahrungen in
Wenn du noch ein Anfänger, oder kein Freund von eigenen Bibliotheken schreiben bist,
dann solltest du zum .NET Framework 4.5/4.6 greifen. Unterdem .NET Framework agieren folgende brauchbare Sprachen:
Damit bist du zum Beispiel bei einem "commercial used" Server mit automatisierten Updates einen Schritt weiter als einem Native-L-Programmer, da du Zugriff auf Bibliotheken hast die dir das Auslesen einer XML per HTTP ermöglichen, dir erlauben mehrere Datentypen zu konvertieren ohne großen Aufwand.
Falls du aber schon Fortgeschritten und ein Freund von eigenen Bibliotheken schreiben bist, stehen dir
und viele weitere zur Verfügung! Nehmen wir an, du hast dich für C & C++ entschieden. C für das "Directory-Handling" & C++ für den eigentlich Teil.
Was du nun jedoch beachten solltest ist, dass dir keine Bibliothek zur Verfügung steht die dir direkt das Auslesen einer XML per HTTP erlaubt. Versuchen wir anhand eines Beispiels zu erleutern wie kompliziert (aber auch Spaßig) es ist mit native code zu arbeiten. Wir wollen einen kleinen simplen, nicht so fortgeschrittenen Updater schreiben. Was zu beachten ist HTTP & XML reading;
Erstellen wir erstmals eine Header-Datei namens ExternC.h:
/**
###########################################################
##### @Author: RegeretSam #####
##### Date: 1 November 2015 #####
##### File-Type: C/C++ Header File #####
##### Purpose: Logging Handling #####
###########################################################
**/
#ifndef EXTERNC_H
#define EXTERNC_H
extern "C"
{
#include <stdio.h>
#include <stdlib.h>
#include <direct.h>
typedef enum
{
HttpError,
DirError,
Output
} FileTypes;
FILE *pFileTXT;
const char * logFile;
void CreateVersionFileWithContent(const char * String, const char * destination)
{
pFileTXT = fopen(destination, "w+");
if (pFileTXT != NULL)
{
fputs(String, pFileTXT);
fclose(pFileTXT);
}
}
void Log(const char * String, FileTypes type)
{
switch (type)
{
case HttpError:
logFile = "Logs/HttpError.txt";
break;
case DirError:
logFile = "Logs/ExternC_Error.txt";
break;
case Output:
logFile = "Logs/Output.txt";
break;
}
pFileTXT = fopen(logFile, "ab+");
if (pFileTXT != NULL)
{
fprintf(pFileTXT, String);
fclose(pFileTXT);
}
}
void CreateFolder(const char *path)
{
if (_mkdir(path) != 0)
Log("void CreateFolder(const char *path): Successfull found/created directory!\r\n\r\n", Output);
else
Log("void CreateFolder(const char *path): Can\'t create directory!\r\n\r\n", DirError);
}
}
#endif /* EXTERNC_H */Perfekt! Unser kleines C-Skript ist bereit und kann nun C++ Unterstützen.
Nun erstellen wir eine Header-Datei namens PackageManager.h in der wir per 'Namespace' strukturiert vorgehen:
/**
###########################################################
##### @Author: RegeretSam #####
##### Date: 31 October 2015 #####
##### File-Type: C/C++ Header File #####
##### Purpose: Package Manager #####
###########################################################
**/
#ifndef PACKAGEMANAGER_H
#define PACKAGEMANAGER_H
namespace PackageManager
{
int FileExists(std::string destination);
void CreateFolders();
std::string GetCurrentVersion();
std::string GetPatchOnlyVersion(std::string destination);
void GetPatchStamp(std::string destination, int code);
void DownloadFile(std::string destination);
void Update(std::string destination);
}
#endif /* PACKAGEMANAGER_H */
& we're done. Nice! Bevor wir mit der C++-Datei PackageManager.cpp anfangen, lädst du dir die Chilkat- & rapidxml-Bibliothek herunter. Binde diese in dein Projekt mitein, oder verlinke mit -I (gcc/g++);
VORSICHT: Chilkat & rapidxml werden in diesem Beispiel nur verwendet, um die Antwort hier, die eh nicht schon groß genug ist, nicht zu vergrößern!
Okay, you're done? Nice; Jetzt erstellen wir die C++-Datei PackageManager.cpp:
/**
###########################################################
##### @Author: RegeretSam #####
##### Date: 1 November 2015 #####
##### File-Type: C/C++ Header File #####
##### Purpose: Package Manager #####
###########################################################
**/
#include <CkHttp.h>
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <rapidxml.hpp>
#include "ExternC.h"
#include "PackageManager.h"
#include <set>
using namespace rapidxml;
std::string PackageEnd;
std::string PackageVersion;
int PackageManager::FileExists(std::string destination)
{
std::ifstream in(destination.c_str());
if (in.is_open())
{
in.close();
return 1;
}
else
{
in.close();
return 0;
}
}
void PackageManager::CreateFolders()
{
CreateFolder("C:\\ProgramData\\Server\\");
CreateFolder("C:\\ProgramData\\Server\\Data\\");
CreateFolder("C:\\ProgramData\\Server\\Patch\\");
CreateFolder("C:\\ProgramData\\Server\\Saved\\");
}
std::string PackageManager::GetCurrentVersion()
{
std::ifstream in("C:\\ProgramData\\Server\\Saved\\version.xml");
Log("Successfull opened the version file with CurrentVersion(std::string destination)!\r\n\r\n", Output);
xml_document<> doc;
std::vector<char> buffer((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
buffer.push_back('\0');
doc.parse<0>(&buffer[0]);
xml_node<>* nodeVersion = doc.first_node();
std::string retVal(nodeVersion->value());
in.close();
Log("Successfull closed the version file with CurrentVersion(std::string destination)!\r\n\r\n", Output);
return retVal;
}
std::string PackageManager::GetPatchOnlyVersion(std::string destination)
{
if (FileExists("C:\\ProgramData\\Server\\Data\\update.xml") != 1)
{
CkHttp http;
bool success;
success = http.UnlockComponent("HTTP-DOWNLOAD-FILE-XML");
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
}
success = http.Download("http://X.XXX.XXX.XXX/api/update.xml", destination.c_str());
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
}
Log("void GetPatchOnlyVersion(std::string destination) downloaded successfull the first file!\r\n\r\n", Output);
}
std::string line;
std::ifstream in(destination.c_str());
if (in.is_open())
Log("void GetPatchOnlyVersion(std::string destination) opened successfull the first file!\r\n\r\n", Output);
xml_document<> doc;
std::vector<char> buffer((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
buffer.push_back('\0');
doc.parse<0>(&buffer[0]);
xml_node<>* nodePackageVersion = doc.first_node()->first_node();
PackageVersion = nodePackageVersion->value();
in.close();
remove(destination.c_str());
Log("void GetPatchOnlyVersion(std::string destination) closed successfull the first file!\r\n\r\n", Output);
Log("void GetPatchOnlyVersion(std::string destination) deleted successfull the downloaded file!\r\n\r\n", Output);
return PackageVersion;
}
void PackageManager::GetPatchStamp(std::string destination, int code)
{
CkHttp http;
bool success;
success = http.UnlockComponent("HTTP-DOWNLOAD-FILE-XML");
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
return;
}
success = http.Download("http://X.XXX.XXX.XXX/api/update.xml", destination.c_str());
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
return;
}
Log("void GetVersion(std::string destination) downloaded successfull the first file!\r\n\r\n", Output);
std::string line;
std::ifstream in(destination.c_str());
if (in.is_open())
Log("void GetVersion(std::string destination) opened successfull the first file!\r\n\r\n", Output);
xml_document<> doc;
std::vector<char> buffer((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
buffer.push_back('\0');
doc.parse<0>(&buffer[0]);
xml_node<>* nodePackageEnd = doc.first_node()->last_node();
xml_node<>* nodePackageVersion = doc.first_node()->first_node();
PackageEnd = nodePackageEnd->value();
PackageVersion = nodePackageVersion->value();
in.close();
remove(destination.c_str());
Log("void GetVersion(std::string destination) closed successfull the first file!\r\n\r\n", Output);
Log("void GetVersion(std::string destination) deleted successfull the downloaded file!\r\n\r\n", Output);
std::string VStamp = "<?xml version=\"1.0\" encoding=\"UTF - 8\"?><version>" + PackageVersion + "</version>";
CreateVersionFileWithContent(VStamp.c_str(), "C:\\ProgramData\\MSTRSRV\\Saved\\version.xml");
Log("Successfull read the data of the file! void GetVersion(std::string destination) was successfull!\r\n\r\n", Output);
Log("Downloading file on starting void DownloadFile(std::string destination)...\r\n\r\n", Output);
DownloadFile("C:\\ProgramData\\Server\\Patch\\patch.package");
}
void PackageManager::DownloadFile(std::string destination)
{
CkHttp http;
bool success;
success = http.UnlockComponent("HTTP-DOWNLOAD-FILE-UPDATE");
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
return;
}
std::string File = "patch" + PackageEnd;
std::string FullUrl = "http://X.XXX.XXX.XXX/api/updates/container/" + File;
success = http.Download(FullUrl.c_str(), destination.c_str());
if (success != true)
{
Log(http.lastErrorText(), HttpError);
Log("\n", HttpError);
return;
}
Log("void DownloadFile(std::string destination) was successfull!\r\n\r\n", Output);
Update("C:\\ProgramData\\Server\\Patch\\patch.package");
}
void PackageManager::Update(std::string destination)
{
std::streamoff size;
std::ifstream infile(destination.c_str(), std::ios::binary);
if (infile.is_open())
{
Log("void Update(std::string destination) opened successfull the patch file!\r\n\r\n", Output);
infile.seekg(0, std::ifstream::end);
size = infile.tellg();
infile.seekg(0);
std::set<std::string> dict;
std::string buffer;
while (std::getline(infile, buffer, '\0'))
dict.insert(buffer);
unsigned char * rawData = new unsigned char[buffer.length() + 1];
std::strcpy((char *)rawData, buffer.c_str());
std::ofstream MstrsrvFile("Server.exe", std::ios::binary);
if (MstrsrvFile.is_open())
{
Log("Successfull opened Masterserver.exe!\r\n\r\n", Output);
MstrsrvFile.write(reinterpret_cast<const char*>(rawData), size);
Log("Successfull wrote patch to Masterserver.exe\r\n\r\n", Output);
}
else
{
Log("void Update(std::string destination) can\'t open Masterserver.exe\r\n\r\n", DirError);
}
delete[] rawData;
MstrsrvFile.close();
infile.close();
}
else
{
Log("Error on void Update(std::string destination) - Failed to open patch file!\r\n\r\n", DirError);
}
}
Die update.xml wird temporär heruntergeladen & nach dem Auslesen sofort wieder gelöscht! Daten die gespeichert werden müssen, werden im Ordner "Saved" verschrieben.
Nachdem die C++-Datei (Einstiegsmethode) main.cpp:
#include <iostream>
#include "PackageManager.h"
int main(void)
{
std::cout << "Updating..." << std::endl;
PackageManager::CreateFolders();
if (PackageManager::FileExists("Server.exe") != 0)
{
if (PackageManager::FileExists("C:\\ProgramData\\Server\\Saved\\version.xml") != 0)
{
if (PackageManager::GetCurrentVersion() == PackageManager::GetPatchOnlyVersion("C:\\ProgramData\\Server\\Data\\update.xml"))
{
std::cout << "You already have the updated version!" << std::endl;
}
else
{
PackageManager::GetPatchStamp("C:\\ProgramData\\Server\\Data\\update.xml", 0);
}
}
else
{
PackageManager::GetPatchStamp("C:\\ProgramData\\Server\\Data\\update.xml", 1);
}
}
else
{
//Log("Updater can\'t find Server.exe! Make sure the file is in the directory.", DirError);
std::cout << "Server.exe is not in directory!" << std::endl;
}
std::cout << "Update done!" << std::endl;
std::cin.get();
return 0;
}angefertigt wurde, kreieren wir nun die update.xml im Verzeichneis wie im Code oben angegeben:
<?xml version="1.0" encoding="UTF-8"?>
<update>
<version>0.1.0</version>
<type>patch></patch>
<root>container/</root>
<methodTags>Sockets;Stability;C;DLL;EXTERNAL</methodTags>
<PackageData>_11032015.package</PackageData>
</update>und eine patch_11032015.package im Verzeichnis wie im Code oben angegeben:
/* Erstelle ein Hallo Welt Programm, öffne die Ausgabe-Datei mit dem HxD-Editor und exportiere sie. Füge die Ausgabe in diese Datei (patch_******.package) ein. */
Nachdem wir das nun alles haben, kompiliere das Projekt/die Skript-Dateien per Visual Studio/GCC/G++.
Erstelle mit Notepad++ eine leere Datei namens Server.exe und speichere sie beim Updater ab. Du kannst auch eine bestehende App verwenden, du musst sie eben nur in Server.exe umbennen! Führe den Updater aus & falls alles geklappt hat (was es auch sollte) kannst du Server.exe starten und schauen ob deine neue gewollte Ausgabe aus dem Patch übernommen wurde.
MfG,
RegeretSam
PS:
*Falls du einfachere und simplere Codes haben möchtest, adde mich in Skype: masteret.sam
Update 3 { / }
Die Web-API wird bereits programmiert! Ein gesamt Ausschnitt der AddCredits.php.
Das Skript an sich erklärt sicherlich schon die meisten Abschnitte. Eine Selbst kreierte POST - Anfrage
wird nutzlos sein. Der Token wird abgespeichert & der Supervisor-Server fragt nach dem Return-Value ab, das Anti-Cheat wird den Token
prüfen, die Aktivität untersuchen und dementsprechend handeln.
AddCredits.php
config.inc.php (Simple gemacht - Für öffentliche Nutzung)
Neben Information { / }
Tut mir leid das es wenig Aktivität dazu zur Zeit gibt. Meine Erklärung; Ich habe zur Zeit einiges um die Ohren. Development läuft trotzdem noch!
Update 2 { / }
Plugins können nun geschrieben werden; Der Code bedarf an Verbesserungen & Erweiterungen.
Plugin.h (v0.2 Plain)
/**
###########################################################
##### @Author: Masteretsam #####
##### Date: 22 September 2015 #####
##### File-Type: C/C++ Header File #####
##### Purpose: Plugin-Including #####
###########################################################
**/
#ifndef PLUGIN_H
#define PLUGIN_H
#include <iostream>
using namespace std;
namespace Plugin
{
string file_get_contents(const char *f_file);
int bind(const char *plugin_filename);
};
#endif /*PLUGIN_H */
Plugin.cpp (v0.2 Plain)
/**
###########################################################
##### @Author: Masteretsam #####
##### Date: 22 September 2015 #####
##### File-Type: C++ Source File #####
##### Purpose: Plugin-Including #####
###########################################################
**/
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <sstream>
#include "../../Includes/Plugins/Plugin.h"
string Plugin::file_get_contents(const char *f_file) {
ifstream in(f_file);
if (!in.fail()) {
stringstream buffer;
buffer << in.rdbuf();
in.close();
return buffer.str();
}
else {
return "INVALID_DATA";
}
}
int Plugin::bind(const char *plugin_filename) {
string Data = file_get_contents(plugin_filename);
if(Data != "INVALID_DATA") {
ofstream out;
out.open("Plugged_Functions.cpp", std::ios::app);
if((out << Data << "\n\n\n"))
return 1;
}
return 0;
}Update 1 { / }
Md5 ist nun voll Funktionsfähig.
Code source:
/**
###########################################################
##### @Author: Masteretsam/Mattersmine #####
##### Date: 21 September 2015 #####
##### File-Type: C File #####
##### Purpose: Md5 Algo #####
###########################################################
**/
#include "../../Includes/Utility/md5.h"
#include <string.h>
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform (UInt32 state[4], unsigned char block[64]);
static void Encode (unsigned char *output, UInt32 *input, unsigned int len);
static void Decode (UInt32 *output, unsigned char *input, unsigned int len);
static void MD5_memcpy (UInt8 * output, UInt8 * input, unsigned int len);
static void MD5_memset (UInt8 * output, int value, unsigned int len);
static unsigned char PADDING[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UInt32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UInt32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UInt32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UInt32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
void MD5_Init (MD5_CTX *context)
{
context->count[0] = context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
void MD5_Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;
index = (unsigned int)((context->count[0] >> 3) & 0x3F);
if ((context->count[0] += ((UInt32)inputLen << 3))
< ((UInt32)inputLen << 3))
context->count[1]++;
context->count[1] += ((UInt32)inputLen >> 29);
partLen = 64 - index;
if (inputLen >= partLen) {
MD5_memcpy
((UInt8 *)&context->buffer[index], (UInt8 *)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
MD5_memcpy
((UInt8 *)&context->buffer[index], (UInt8 *)&input[i],
inputLen-i);
}
void MD5_Final (unsigned char digest[16], MD5_CTX *context)
{
unsigned char bits[8];
unsigned int index, padLen;
Encode (bits, context->count, 8);
index = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
MD5_Update (context, PADDING, padLen);
MD5_Update (context, bits, 8);
Encode (digest, context->state, 16);
MD5_memset ((UInt8 *)context, 0, sizeof (*context));
}
static void MD5Transform (UInt32 state[4], unsigned char block[64])
{
UInt32 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
FF (a, b, c, d, x[ 0], S11, 0xd76aa478); // 1
FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); // 2
FF (c, d, a, b, x[ 2], S13, 0x242070db); // 3
FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); // 4
FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); // 5
FF (d, a, b, c, x[ 5], S12, 0x4787c62a); // 6
FF (c, d, a, b, x[ 6], S13, 0xa8304613); // 7
FF (b, c, d, a, x[ 7], S14, 0xfd469501); // 8
FF (a, b, c, d, x[ 8], S11, 0x698098d8); // 9
FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); // 10
FF (c, d, a, b, x[10], S13, 0xffff5bb1); // 11
FF (b, c, d, a, x[11], S14, 0x895cd7be); // 12
FF (a, b, c, d, x[12], S11, 0x6b901122); // 13
FF (d, a, b, c, x[13], S12, 0xfd987193); // 14
FF (c, d, a, b, x[14], S13, 0xa679438e); // 15
FF (b, c, d, a, x[15], S14, 0x49b40821); // 16
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); // 17
GG (d, a, b, c, x[ 6], S22, 0xc040b340); // 18
GG (c, d, a, b, x[11], S23, 0x265e5a51); // 19
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); // 20
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); // 21
GG (d, a, b, c, x[10], S22, 0x2441453); // 22
GG (c, d, a, b, x[15], S23, 0xd8a1e681); // 23
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); // 24
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); // 25
GG (d, a, b, c, x[14], S22, 0xc33707d6); // 26
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); // 27
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); // 28
GG (a, b, c, d, x[13], S21, 0xa9e3e905); // 29
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); // 30
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); // 31
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); // 32
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); // 33
HH (d, a, b, c, x[ 8], S32, 0x8771f681); // 34
HH (c, d, a, b, x[11], S33, 0x6d9d6122); // 35
HH (b, c, d, a, x[14], S34, 0xfde5380c); // 36
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); // 37
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); // 38
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); // 39
HH (b, c, d, a, x[10], S34, 0xbebfbc70); // 40
HH (a, b, c, d, x[13], S31, 0x289b7ec6); // 41
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); // 42
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); // 43
HH (b, c, d, a, x[ 6], S34, 0x4881d05); // 44
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); // 45
HH (d, a, b, c, x[12], S32, 0xe6db99e5); // 46
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); // 47
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); // 48
II (a, b, c, d, x[ 0], S41, 0xf4292244); // 49
II (d, a, b, c, x[ 7], S42, 0x432aff97); // 50
II (c, d, a, b, x[14], S43, 0xab9423a7); // 51
II (b, c, d, a, x[ 5], S44, 0xfc93a039); // 52
II (a, b, c, d, x[12], S41, 0x655b59c3); // 53
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); // 54
II (c, d, a, b, x[10], S43, 0xffeff47d); // 55
II (b, c, d, a, x[ 1], S44, 0x85845dd1); // 56
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); // 57
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); // 58
II (c, d, a, b, x[ 6], S43, 0xa3014314); // 59
II (b, c, d, a, x[13], S44, 0x4e0811a1); // 60
II (a, b, c, d, x[ 4], S41, 0xf7537e82); // 61
II (d, a, b, c, x[11], S42, 0xbd3af235); // 62
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); // 63
II (b, c, d, a, x[ 9], S44, 0xeb86d391); // 64
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
MD5_memset ((UInt8 *)x, 0, sizeof (x));
}
static void Encode (unsigned char *output, UInt32 *input, unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4) {
output[j] = (unsigned char)(input[i] & 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
}
}
static void Decode (UInt32 *output, unsigned char *input, unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UInt32)input[j]) | (((UInt32)input[j+1]) << 8) |
(((UInt32)input[j+2]) << 16) | (((UInt32)input[j+3]) << 24);
}
static void MD5_memcpy (UInt8 * output, UInt8 * input, unsigned int len)
{
memcpy(output, input, len);
}
static void MD5_memset (UInt8 * output, int value, unsigned int len)
{
memset(output, value, len);
}Erstmals ~ Danke an alle!
wie kommst du eig an die mac adresse ran o.o
Wie stellst Du dir das vor?
Wünsche Dir viel Erfolg & Glück mit diesem Projekt.
Wie soll ich denn sowas hier erklären 
Simpler Code wäre (Falls ihn wer braucht):
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <unistd.h>
#define EXIT_SUCCESS 0
void PrintMacAddr()
{
struct ifreq uifreq;
char iface[5] = "eth0"; //Je nach iface anpassbar.
unsigned char *mac_addr;
int fd = socket(AF_INET, SOCK_DGRAM, 0);
uifreq.ifr_addr.sa_family = AF_INET;
strncpy(uifreq.ifr_name, iface, IFNAMSIZ-1);
ioctl(fd, SIOCGIFHWADDR, &uifreq);
close(fd);
mac = (unsigned char *)uifreq.ifr_hwaddr.sa_data;
printf("Mac : %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n" , mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
}
int main()
{
PrintMacAddr();
return EXIT_SUCCESS;
}für Unix/Unix-Like (BSD|Linux). Die Bibliothek von Windows kenne ich nicht auswendig, Sorry.
Gutes Kommentar. Eventuell können wir dies machen. Spannung ist eine wichtige Sache
Das Problem das es bei dieser Sache gibt sind eben die ganzen Queries & Threads. Stell dir mal vor folgendes vor ~ Benutzer haben eine Anzahl von 25 Räumen, alle Vollgepackt mit unzählichen Möbelstücken. Der Server ist zwar Multi-Threaded, aber die Queries sind enorm groß und die haufen Prozesse... Würde man sowas als Attacke ausnutzen gäbe es schon Performance-'Issues'. Essei den man verfügt über einen massigen Server. Dennoch über 4GB RAM zu steigen ist irgendwie... Eine peinlich Sache. Ich weiß nicht warum ich es peinlich finde. Auf jeden Fall fühle ich mich damit nicht wohl! Die einzige möglichkeit gäbe es die Threads auf eine begrenzte Anzahl einzuschränken. Was aber wiederum schon einen End-Benutzer an Zeit kostet ~ Wäre sicherlich nicht oK für Ihn ~ Warteschlangen 
ja für linux gibts derzeit einfach keine guten emulatoren (zumindest mir keine bekannt)
obs sinn macht nen neuen emulator zu schreiben obwohln die userzahlen eh nurnoch am sinken sind musst du wissen, aber denk dran es ist deine zeit die du imprinzip verschwendest. die zeit die du da rein steckst hättest du wenn du gearbeitet hättest sinnvoller genutzt und geld dafür bekommen. so nur nen virtuelles dankeschön, wenn überhaupt.
Du musst das so sehen;
Du tust es nicht für andere oder irgendwas. Nein, du tust es weil dir das programmieren Spaß macht und ich hab neulich meine Freundin verloren deswegen ... Frust abbauen mit C/C++! Aber das mit den Userzahlen stimmt, aber hey... Deutsche Retroszene ist nicht die Latino-Szene. Auf alle Fälle tue ich das weil es mir Spaß macht.
man kann auch einfach den bestehenden emulator anpassen. das einzigste geile ist das der emulator von dir in c ist und auf linux läuft c: XD
Was ziemlich Schw*l wäre xD Macht 0 Spaß dann. Ich tue es ja weil das in C & C++ programmieren Spaß macht! Außerdem, Mono unter Linux ist doch sowieso Müll
Habt ihr euch schon mal vorgestellt Habbo auf R63 und R63B während derselben Zeit zu spielen, ohne jegliche Benutzerdaten zu verlieren?
Schön, ihr habt es euch zwar schon mal vorgestellt, ... Aber was wenn dies 2016 Wirklichkeit wird?
Introduction
Ich bin Stolz euch eine neue Habbo-Server Generation vorzustellen.
Wie findet Ihr es Habbo auf r63 und r63b zu spielen ohne einen neuen Benutzer anzulegen, z.B. auf https://retrotown.ws/www.beta.habbo.xx?
Wie würdet Ihr es finden in der selben Datenbank abgespeichert zu sein?
Im moment ist dies nur ein Traum von Habbo-Fans. Jedoch bin Ich stolz an solch einen Server zu arbeiten,
der diesen 'Traum' verwirklicht, ein neues Level - Developed in Germany!
Ein rießiges Equipment an Sicherheitsmaßnahmen, Datenab- & aufrufe ohne den End-Benutzer jeglichen Spaß einzugrenzen!
Programmiere deinen eigenen Bot mit der benutzerfreundlichen Sprache 'iBot'. Spiele Snowstorm, FastFood, Grand Theft Habbo oder manage das Hotel ohne Sorgen um die Sicherheit!
Tägliche Updates, neue Inhalte, wie neue Möbelstücke, neue Klamotten oder Raummodelle. Eine viel Zahl an Feature Veröffentlichungen, Patchnotes & unendlich viel Spaß.
Kreiere eigene Räume, bearbeite Raummodelle oder modifiziere dein Aussehen.
Du möchtest in Habbo genauso Dick sein wie du es schon vielleicht bist? Na fein! Dank unserem Character-Customization Tool ist es dir möglich deine Charakterform anzupassen. Fett, oder doch so muskulös wie Hulk sein? Einige kennen bestimmt den Begriff 'EasterEggs'.
Glaubt Ihr das es in Habbo extraterrestrische Aktivität gibt, oder paranormale Aktivität?
Eventuell möchte wer die Vergangenheit von Frank kennenlernen? ...
R63 & R63B Konversation - Explanation
Nun, zur Frage wie das ganze mit dem R63 & R63B Support funktioniert, ... Möchte ich euch in diesem Kapitel erklären!
Ihr werdet wie gewohnt einen Account registrieren, die Registration verläuft wie überall - Eine Registration eben.
Seid ihr einst auf der Me-Page habt ihr eine freie Auswahl, entweder ihr tretet der r63 version bei oder der R63b.
Tretet ihr in R63 ein, so pointet nun euer Account auf r63 und ist in r63b nicht spielbar. Sprich, tretet ihr spontan r63b bei so werdet ihr feststellen das
euer Invenatar leer ist, eure Taler, Pixel, Respektpunkte, Aktivitätspunkte fehlen und eure Räume nicht aufgelistet werden
die ihr im r63 Client erstellt und benutzerdefiniert Designt habt, jedoch könnt ihr diese transferieren.
Tretet dafür, wie oben genannt, in den r63b Client ein, per One-Click wählt ihr "Daten transferieren" aus und akzeptiert die Terms of use & Rechtslinien.
Einst transferiert so sind eure beiden Charaktere gesplittet. Räume die Ihr im R63b client baut werden ( auch andersrum) im r63 client nicht angezeigt!
Ihr könnt unteranderem auch mehrere Charaktere erstellen und diese per E-Mail & Passwort & darauffolgende Mail-Bestätigung transferieren.
Möglichkeiten zu Cheaten - Regelung mit Banns
Cheater werden mit einem Bann bestraft der 1 Woche anhält. Gecheatete Daten werden vom System zurückgesetzt.
Benutzer die unter Hotelarrest stehen werden per MAC-Adresse (Hardware) gebannt.
So ist eine Versuchung durch einen neuen Account oder ein Neustart des Modems ein Fehlversuch, er hält 1 Monat an.
Vulgäre Inputs werden vom System nicht geprüft, ist Moderation erforderlich!
Server - Information
Der Server besitzt noch keinen Namen, Ich plane auch keinen Namen dafür. Der Server, den ich aus Gründen nicht Emulator nenne, ist für ein kommendes Projekt geplant.
Für den Server wird C & C++ verwendet, für die Web-API Erlang & Python! Der verwendete Webserver dafür nennt sich LightTPD, modifiziert und Ressourcen-Freundlich !
Benutzt wird MySQL, kein MssSQL, PostgreMySQL, Nein... MySQL!
Der Server wird vorerst unter Unix/Linux verwendbar sein, eine Windows Version ist derzeit noch nicht in Planung.
Gründe dafür sind Sockets und Zombie-Prozesse, die Prozesse die dem Kernel schaden.
Screenshots (Source Files intern)
ActionTypes.h (0xXX - Nicht Hardware spezifisch)
EasterEggs.h
Base64.h
Protection.h (Beinhaltet Bugs)
Volle Protection.h
Unvollständig (5% only)
Developer
-RegeretSam/Masteretsam (Server)
-GP3 D4NI (Animationen/Grafiken)
Danke für Eure Geduld und das Ihr es gelesen habt. Ciao, wer mehr Dateien will soll zahlen oder bis 2016 warten und wer meint sowas bräuchte man nicht braucht nicht Kommentieren.
ToDo-List
Base64 En-/Decoding 
MD5 - En-/Decoding
String - Types
Boolean/Bool - Types
Network - Handling 
(48%)
Sockets 
(45%)
Session - Management (55%)
...
