lolcat/minecraft-pe-0.6.1
1
0
Fork 0
mirror of https://gitea.sffempire.ru/Kolyah35/minecraft-pe-0.6.1.git synced 2026-03-30 20:13:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

server compilable

Browse Source
This commit is contained in:
Kolyah35
2026-03-26 03:48:08 +03:00
parent cbd81b47ce
commit a45c01d013
96 changed files with 3344 additions and 7975 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
CMakeLists.txt
View File

@@ -39,6 +39,8 @@ if (${PLATFORM} STREQUAL "Desktop")
set(EXTRA_LIBS pthread m)
endif()
include_directories("glad/include")
elseif (${PLATFORM} STREQUAL "Web")
set(PLATFORM_CPP "PLATFORM_WEB")
set(EXTRA_LIBS "idbfs.js")
@@ -114,34 +116,38 @@ CPMAddPackage(
# TODO: Clear this paths with *
file(GLOB SERVER_SOURCES
"project/lib_projects/raknet/jni/RaknetSources/*.cpp"
"src/NinecraftApp.cpp"
"src/Performance.cpp"
"src/SharedConstants.cpp"
"src/Minecraft.cpp"
"src/MinecraftServer.cpp"
"src/App.cpp"
"src/IPlatform.cpp"
"src/client/IConfigListener.cpp"
"src/client/Minecraft.cpp"
"src/client/OptionStrings.cpp"
"src/client/Option.cpp"
"src/client/Options.cpp"
"src/client/OptionsFile.cpp"
"src/client/ServerProfiler.cpp"
"src/client/gamemode/CreativeMode.cpp"
"src/client/gamemode/GameMode.cpp"
"src/client/gamemode/SurvivalMode.cpp"
# "src/client/IConfigListener.cpp"
# "src/client/Minecraft.cpp"
# "src/client/OptionStrings.cpp"
# "src/client/Option.cpp"
# "src/client/Options.cpp"
# "src/client/OptionsFile.cpp"
# "src/client/ServerProfiler.cpp"
"src/client/player/LocalPlayer.cpp"
"src/client/player/RemotePlayer.cpp"
"src/client/player/input/KeyboardInput.cpp"
# "src/client/gamemode/CreativeMode.cpp"
# "src/client/gamemode/GameMode.cpp"
# "src/client/gamemode/SurvivalMode.cpp"
# "src/client/player/LocalPlayer.cpp"
# "src/client/player/RemotePlayer.cpp"
# "src/client/player/input/KeyboardInput.cpp"
"src/gamemode/*.cpp"
"src/locale/I18n.cpp"
"src/main.cpp"
"src/main_dedicated.cpp"
"src/nbt/Tag.cpp"
"src/network/ClientSideNetworkHandler.cpp"
"src/network/NetEventCallback.cpp"
"src/network/Packet.cpp"
"src/network/RakNetInstance.cpp"
@@ -152,11 +158,7 @@ file(GLOB SERVER_SOURCES
"src/platform/HttpClient.cpp"
"src/platform/PngLoader.cpp"
"src/platform/time.cpp"
"src/platform/input/Controller.cpp"
"src/platform/input/Keyboard.cpp"
"src/platform/input/Mouse.cpp"
"src/platform/input/Multitouch.cpp"
"src/platform/server/PlatformServer.cpp"
"src/server/ArgumentsSettings.cpp"
"src/server/ServerLevel.cpp"
@@ -369,7 +371,7 @@ if(${PLATFORM} MATCHES "Web")
endif()
# Client
target_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" ${PLATFORM})
target_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" "${PLATFORM_CPP}")
target_link_libraries(${PROJECT_NAME} zlib ${PNG_LIB} OpenAL::OpenAL glfw ${EXTRA_LIBS})
if (OpenSSL_FOUND)

26
src/App.cpp Normal file
View File

@@ -0,0 +1,26 @@
#include "App.h"
#include "IPlatform.h"
#include "platform/server/PlatformServer.h"
#include "platform/glfw/PlatformGlfw.h"
std::unique_ptr<IPlatform> App::CreatePlatform() {
#if defined(STANDALONE_SERVER)
return std::make_unique<PlatformServer>();
#elif defined(PLATFORM_DESKTOP)
return std::make_unique<PlatformGlfw>();
#else
static_assert(false, "Unsupported platform!");
#endif
}
void App::run() {
init();
m_platform->runMainLoop(*this);
}
void App::swapBuffers() {
m_platform->swapBuffers();
}

90
src/App.h
View File

@@ -1,6 +1,6 @@
#ifndef APP_H__
#define APP_H__
#pragma once
#include <memory>
#ifdef __APPLE__
#define NO_EGL
#endif
@@ -8,47 +8,36 @@
#define NO_EGL
#endif
#include "AppPlatform.h"
#include <IPlatform.h>
#ifndef NO_EGL
#include <EGL/egl.h>
#endif
#include "platform/log.h"
typedef struct AppContext {
#ifndef NO_EGL
EGLDisplay display;
EGLContext context;
EGLSurface surface;
#endif
AppPlatform* platform;
bool doRender;
} AppContext;
class App
{
// typedef struct AppContext {
// #ifndef NO_EGL
// EGLDisplay display;
// EGLContext context;
// EGLSurface surface;
// #endif
// AppPlatform* platform;
// bool doRender;
// } AppContext;
class App {
protected:
std::unique_ptr<IPlatform> m_platform;
public:
App()
: _finished(false),
_inited(false)
{
_context.platform = 0;
}
static std::unique_ptr<IPlatform> CreatePlatform();
App(std::unique_ptr<IPlatform> platform) : m_platform(std::move(platform)), m_finished(false), m_inited(false) {}
App() = delete;
virtual ~App() {}
void init(AppContext& c) {
_context = c;
init();
_inited = true;
}
bool isInited() { return _inited; }
void run();
virtual AppPlatform* platform() { return _context.platform; }
void onGraphicsReset(AppContext& c) {
_context = c;
onGraphicsReset();
}
bool isInited() { return m_inited; }
virtual void audioEngineOn () {}
virtual void audioEngineOff() {}
@@ -58,30 +47,25 @@ public:
virtual void loadState(void* state, int stateSize) {}
virtual bool saveState(void** state, int* stateSize) { return false; }
void swapBuffers() {
#ifndef NO_EGL
if (_context.doRender)
eglSwapBuffers(_context.display, _context.surface);
#endif
}
void swapBuffers();
// {
// #ifndef NO_EGL
// if (_context.doRender)
// eglSwapBuffers(_context.display, _context.surface);
// #endif
// m_platform->swapBuffers();
// }
virtual void draw() {}
virtual void update() {};// = 0;
virtual void setSize(int width, int height) {}
virtual void update() = 0;
virtual void quit() { _finished = true; }
virtual bool wantToQuit() { return _finished; }
virtual void quit() { m_finished = true; }
virtual bool wantToQuit() { return m_finished; }
virtual bool handleBack(bool isDown) { return false; }
protected:
virtual void init() {}
//virtual void onGraphicsLost() = 0;
virtual void onGraphicsReset() = 0;
virtual void init() { m_inited = true;}
private:
bool _inited;
bool _finished;
AppContext _context;
bool m_inited = false;
bool m_finished = false;
};
#endif//APP_H__

10
src/AppConstants.h
View File

@@ -1,10 +0,0 @@
#ifndef _MINECRAFT_APPCONSTANTS_H_
#define _MINECRAFT_APPCONSTANTS_H_
#define APP_VERSION_STRING "Demo"
#define APP_NAME "Minecraft - Pocket Edition " APP_VERSION_STRING
#endif

143
src/AppPlatform.h
View File

@@ -1,143 +0,0 @@
#ifndef APPPLATFORM_H__
#define APPPLATFORM_H__
#include <vector>
#include <string>
#include <cstring>
#include "client/renderer/TextureData.h"
typedef std::vector<std::string> StringVector;
/*
typedef struct UserInput
{
static const int STATUS_INVALID = -1;
static const int STATUS_NOTINITED = -2;
static const int STATUS_OK = 1;
static const int STATUS_CANCEL = 0;
UserInput(int id)
: _id(id),
status(STATUS_NOTINITED)
{}
UserInput(int id, int status)
: _id(id),
status(status)
{}
int getId() { return _id; }
int status;
private:
int _id;
} UserInput;
class UserInputStatus {
int _status;
public:
UserInputStatus(int status)
: _status(status)
{}
bool isAnswered() { return _status >= 0; }
bool isOk() { return _status == UserInput::STATUS_OK; }
bool isCancel() { return _status == UserInput::STATUS_CANCEL; }
};
*/
class BinaryBlob {
public:
BinaryBlob()
: data(NULL),
size(-1) {}
BinaryBlob(unsigned char* data, unsigned int size)
: data(data),
size(size) {}
unsigned char* data;
int size;
};
class PlatformStringVars {
public:
static const int DEVICE_BUILD_MODEL = 0;
};
class AppPlatform
{
public:
AppPlatform() : keyboardVisible(false) {}
virtual ~AppPlatform() {}
virtual void saveScreenshot(const std::string& filename, int glWidth, int glHeight) {}
virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
virtual void playSound(const std::string& fn, float volume, float pitch) {}
virtual void hideCursor(bool hide) {}
virtual void showDialog(int dialogId) {}
virtual void createUserInput() {}
bool is_big_endian(void) {
union {
unsigned int i;
char c[4];
} bint = {0x01020304};
return bint.c[0] == 1;
}
void createUserInput(int dialogId)
{
showDialog(dialogId);
createUserInput();
}
virtual int getUserInputStatus() { return 0; }
virtual StringVector getUserInput() { return StringVector(); }
virtual std::string getDateString(int s) { return ""; }
//virtual void createUserInputScreen(const char* types) {}
virtual void uploadPlatformDependentData(int id, void* data) {}
virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
virtual void _tick() {}
virtual int getScreenWidth() { return 854; }
virtual int getScreenHeight() { return 480; }
virtual float getPixelsPerMillimeter() { return 10; }
virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
virtual bool isPowerVR() {
return false;
}
virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
#ifdef __APPLE__
virtual bool isSuperFast() = 0;
#endif
virtual void openURL(const std::string& url) {}
virtual void finish() {}
virtual bool supportsTouchscreen() { return false; }
virtual void vibrate(int milliSeconds) {}
virtual std::string getPlatformStringVar(int stringId) {
return "<getPlatformStringVar NotImplemented>";
}
virtual void showKeyboard() {
keyboardVisible = true;
}
virtual void hideKeyboard() {
keyboardVisible = false;
}
virtual bool isKeyboardVisible() {return keyboardVisible;}
protected:
bool keyboardVisible;
};
#endif /*APPPLATFORM_H__*/

12
src/AppPlatform_glfw.cpp
View File

@@ -1,12 +0,0 @@
#include "AppPlatform_glfw.h"
float AppPlatform_glfw::getPixelsPerMillimeter() {
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
int width_mm, height_mm;
glfwGetMonitorPhysicalSize(monitor, &width_mm, &height_mm);
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
return (float)mode->width / (float)width_mm;
}

155
src/AppPlatform_glfw.h
View File

@@ -1,155 +0,0 @@
#ifndef APPPLATFORM_GLFW_H__
#define APPPLATFORM_GLFW_H__
#include "AppPlatform.h"
#include "platform/log.h"
#include "platform/HttpClient.h"
#include "platform/PngLoader.h"
#include "client/renderer/gles.h"
#include "world/level/storage/FolderMethods.h"
#include <png.h>
#include <cmath>
#include <fstream>
#include <sstream>
#include <GLFW/glfw3.h>
#include <ctime>
#include "util/StringUtils.h"
#ifdef _WIN32
#include <windows.h>
#include <shellapi.h>
#endif
#ifdef __EMSCRIPTEN__
#include <emscripten/html5.h>
#endif
static void png_funcReadFile(png_structp pngPtr, png_bytep data, png_size_t length) {
((std::istream*)png_get_io_ptr(pngPtr))->read((char*)data, length);
}
class AppPlatform_glfw: public AppPlatform
{
public:
AppPlatform_glfw()
{
}
BinaryBlob readAssetFile(const std::string& filename) override {
FILE* fp = fopen(("data/" + filename).c_str(), "r");
if (!fp)
return BinaryBlob();
int size = getRemainingFileSize(fp);
BinaryBlob blob;
blob.size = size;
blob.data = new unsigned char[size];
fread(blob.data, 1, size, fp);
fclose(fp);
return blob;
}
void saveScreenshot(const std::string& filename, int glWidth, int glHeight) override {
//@todo
}
__inline unsigned int rgbToBgr(unsigned int p) {
return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
}
TextureData loadTexture(const std::string& filename_, bool textureFolder) override
{
// Support fetching PNG textures via HTTP/HTTPS (for skins, etc)
if (Util::startsWith(filename_, "http://") || Util::startsWith(filename_, "https://")) {
std::vector<unsigned char> body;
if (HttpClient::download(filename_, body) && !body.empty()) {
return loadTextureFromMemory(body.data(), body.size());
}
return TextureData();
}
TextureData out;
std::string filename = textureFolder? "data/images/" + filename_
: filename_;
std::ifstream source(filename.c_str(), std::ios::binary);
if (!source) {
LOGI("Couldn't find file: %s\n", filename.c_str());
return out;
}
std::vector<unsigned char> fileData((std::istreambuf_iterator<char>(source)), std::istreambuf_iterator<char>());
source.close();
if (fileData.empty()) {
LOGI("Couldn't read file: %s\n", filename.c_str());
return out;
}
return loadTextureFromMemory(fileData.data(), fileData.size());
}
TextureData loadTextureFromMemory(const unsigned char* data, size_t size) override {
return loadPngFromMemory(data, size);
}
virtual std::string getDateString(int s) override {
time_t tm = s;
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%F %T", std::localtime(&tm));
return std::string(mbstr);
}
virtual int getScreenWidth() override {
#ifdef __EMSCRIPTEN__
int w, h;
emscripten_get_canvas_element_size("canvas", &w, &h);
return w;
#endif
return 854;
};
virtual int getScreenHeight() override {
#ifdef __EMSCRIPTEN__
int w, h;
emscripten_get_canvas_element_size("canvas", &w, &h);
return h;
#endif
return 480;
};
virtual float getPixelsPerMillimeter() override;
virtual bool supportsTouchscreen() override { return false; /* glfw supports only mouse and keyboard */ }
virtual void hideCursor(bool hide) override {
int isHide = hide ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN;
glfwSetInputMode(window, GLFW_CURSOR, isHide);
}
virtual void openURL(const std::string& url) override {
#ifdef _WIN32
ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
#elif __linux__
std::string command = "xdg-open " + url;
system(command.c_str());
#elif __EMSCRIPTEN__
emscripten_run_script(std::string("window.open('" + url + "', '_blank')").c_str());
#endif
}
GLFWwindow* window;
private:
};
#endif /*APPPLATFORM_GLFW_H__*/

13
src/ErrorCodes.h
View File

@@ -1,13 +0,0 @@
#ifndef ERRORCODES_H__
#define ERRORCODES_H__
namespace ErrorCodes {
enum Enum {
Unknown,
ContainerRefStillExistsAfterDestruction
};
}
#endif /*ERRORCODES_H__*/

14
src/IPlatform.cpp Normal file
View File

@@ -0,0 +1,14 @@
#include <IPlatform.h>
#include <App.h>
#include <fstream>
void IPlatform::runMainLoop(App& app) {
while(!app.wantToQuit()) app.update();
}
ByteVector IPlatform::readAssetFile(const std::string& path) {
std::ifstream instream(path, std::ios::in | std::ios::binary);
std::vector<uint8_t> data((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());
return data;
}

81
src/IPlatform.h Executable file
View File

@@ -0,0 +1,81 @@
#pragma once
#include <vector>
#include <string>
#include "client/renderer/TextureData.h"
#include <cstdint>
typedef std::vector<std::string> StringVector;
typedef std::vector<uint8_t> ByteVector;
class App;
class IPlatform {
public:
IPlatform() : keyboardVisible(false), windowSizeChanged(false), m_targetFrametime(0.f) {}
virtual ~IPlatform() {}
virtual bool init() { return true; }
virtual void swapBuffers() {}
virtual void runMainLoop(App& app);
virtual ByteVector readAssetFile(const std::string& path);
// Mojang functions here
virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
virtual void playSound(const std::string& fn, float volume, float pitch) {}
virtual void hideCursor(bool hide) {}
virtual std::string getDateString(int s) = 0;
virtual void uploadPlatformDependentData(int id, void* data) {}
// virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
virtual void _tick() {}
virtual int getScreenWidth() { return 854; }
virtual int getScreenHeight() { return 480; }
virtual float getPixelsPerMillimeter() { return 10; }
virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
virtual bool isPowerVR() {
return false;
}
virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
#ifdef __APPLE__
virtual bool isSuperFast() = 0;
#endif
virtual void openURL(const std::string& url) {}
virtual void finish() {}
virtual bool supportsTouchscreen() { return false; }
virtual void vibrate(int milliSeconds) {}
virtual std::string getPlatformStringVar(int stringId) = 0;
virtual void showKeyboard() { keyboardVisible = true; }
virtual void hideKeyboard() { keyboardVisible = false; }
virtual bool isKeyboardVisible() { return keyboardVisible; }
virtual void setTargetFPS(int fps) { m_targetFrametime = 1.0 / fps; }
bool isWindowSizeChanged() { return windowSizeChanged; }
virtual void setVSync(bool on) { vsync = on; }
protected:
bool keyboardVisible;
bool windowSizeChanged;
bool vsync;
double m_targetFrametime;
};

502
src/Minecraft.cpp Executable file
View File

@@ -0,0 +1,502 @@
#include <Minecraft.h>
#include "gamemode/CreativeMode.h"
#include "gamemode/SurvivalMode.h"
#include "gamemode/CreatorMode.h"
#include "world/entity/player/Player.h"
#include "world/item/Item.h"
#include "world/item/ItemInstance.h"
#include "world/item/crafting/Recipes.h"
#include "world/level/Level.h"
#include "world/level/tile/entity/TileEntity.h"
#include <string>
#include <cstdlib>
#include "client/gui/Screen.h"
#include "world/level/storage/ExternalFileLevelStorageSource.h"
#if defined(APPLE_DEMO_PROMOTION)
#define NO_NETWORK
#endif
#if defined(RPI)
#define CREATORMODE
#endif
#include "network/RakNetInstance.h"
#include "network/ClientSideNetworkHandler.h"
#include "network/ServerSideNetworkHandler.h"
//#include "network/Packet.h"
#include "world/entity/player/Inventory.h"
#include "world/level/tile/Tile.h"
#include "world/level/storage/LevelStorageSource.h"
#include "world/level/storage/LevelStorage.h"
#include "world/level/chunk/ChunkSource.h"
#include "platform/CThread.h"
#include <IPlatform.h>
#include "util/PerfTimer.h"
#include "util/PerfRenderer.h"
#include "world/entity/MobFactory.h"
#include "world/level/MobSpawner.h"
#include "util/Mth.h"
#include "world/entity/MobCategory.h"
#include "server/ServerLevel.h"
#ifdef CREATORMODE
#include "server/CreatorLevel.h"
#endif
#include "network/command/CommandServer.h"
/*static*/
const char* Minecraft::progressMessages[] = {
"Locating server",
"Building terrain",
"Preparing",
"Saving chunks"
};
// int Minecraft::customDebugId = Minecraft::CDI_NONE;
bool Minecraft::_hasInitedStatics = false;
#if defined(_MSC_VER)
#pragma warning( disable : 4355 ) // 'this' pointer in initialization list which is perfectly legal
#endif
// Minecraft::Minecraft() :
// #ifdef __APPLE__
// _isSuperFast(false),
// #endif
// #if defined(NO_NETWORK)
// raknetInstance = new IRakNetInstance();
// #else
// raknetInstance = new RakNetInstance();
// #endif
// #ifndef STANDALONE_SERVER
// soundEngine = new SoundEngine(20.0f);
// soundEngine->init(this, &options);
// #endif
// //setupPieces();
// #if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
// signal(SIGPIPE, SIG_IGN);
// #endif
// externalCacheStoragePath = '.';
// externalCacheStoragePath = '.';
// }
Minecraft::~Minecraft() {
delete netCallback;
delete raknetInstance;
delete gameMode;
if (level != NULL) {
level->saveGame();
if (level->getChunkSource())
level->getChunkSource()->saveAll(true);
delete level->getLevelStorage();
delete level;
level = NULL;
}
//delete player;
delete storageSource;
delete _commandServer;
MobFactory::clearStaticTestMobs();
// Note: Don't tear down statics if we run on Android
// (we might change this in the future)
#ifndef ANDROID
Biome::teardownBiomes();
Item ::teardownItems();
Tile ::teardownTiles();
Material::teardownMaterials();
Recipes ::teardownRecipes();
TileEntity::teardownTileEntities();
#endif
}
// Only called by server
void Minecraft::selectLevel( const std::string& levelId, const std::string& levelName, const LevelSettings& settings ) {
level = (Level*)new ServerLevel(
storageSource->selectLevel(levelId, false),
levelName,
settings,
SharedConstants::GeneratorVersion
);
// note: settings is useless beyond this point, since it's
// either copied to LevelData (or LevelData read from file)
setLevel(level, "Generating level");
setIsCreativeMode(level->getLevelData()->getGameType() == GameType::Creative);
_running = true;
}
void Minecraft::setLevel(Level* level, const std::string& message, Player* forceInsertPlayer) {
LOGI("Seed is %ld\n", level->getSeed());
if (level != NULL) {
level->raknetInstance = raknetInstance;
gameMode->initLevel(level);
this->level = level;
_hasSignaledGeneratingLevelFinished = false;
#ifdef STANDALONE_SERVER
const bool threadedLevelCreation = false;
#else
const bool threadedLevelCreation = true;
#endif
if (threadedLevelCreation) {
// Threaded
// "Lock"
isGeneratingLevel = true;
generateLevelThread = new CThread(Minecraft::prepareLevel_tspawn, this);
} else {
// Non-threaded
generateLevel("Currently not used", level);
}
}
this->lastTickTime = 0;
this->_running = true;
}
void Minecraft::prepareLevel(const std::string& title) {
LOGI("status: 1\n");
progressStageStatusId = 1;
Stopwatch A, B, C, D;
A.start();
Stopwatch L;
// Dont update lights if we load the level (ok, actually just with leveldata version=1.+(?))
if (!level->isNew())
level->setUpdateLights(false);
int Max = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
int pp = 0;
for (int x = 8; x < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); x += CHUNK_WIDTH) {
for (int z = 8; z < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); z += CHUNK_WIDTH) {
progressStagePercentage = 100 * pp++ / Max;
//printf("level generation progress %d\n", progressStagePercentage);
B.start();
level->getTile(x, 64, z);
B.stop();
L.start();
if (level->isNew())
while (level->updateLights())
;
L.stop();
}
}
A.stop();
level->setUpdateLights(true);
C.start();
for (int x = 0; x < CHUNK_CACHE_WIDTH; x++)
{
for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
{
LevelChunk* chunk = level->getChunk(x, z);
if (chunk && !chunk->createdFromSave)
{
chunk->unsaved = false;
chunk->clearUpdateMap();
}
}
}
C.stop();
LOGI("status: 3\n");
progressStageStatusId = 3;
if (level->isNew()) {
level->setInitialSpawn(); // @note: should obviously be called from Level itself
level->saveLevelData();
level->getChunkSource()->saveAll(false);
level->saveGame();
} else {
level->saveLevelData();
level->loadEntities();
}
progressStagePercentage = -1;
progressStageStatusId = 2;
LOGI("status: 2\n");
D.start();
level->prepare();
D.stop();
A.print("Generate level: ");
L.print(" - light: ");
B.print(" - getTl: ");
C.print(" - clear: ");
D.print(" - prepr: ");
progressStageStatusId = 0;
}
void Minecraft::update() {
timer.advanceTime();
raknetInstance->runEvents(netCallback);
TIMER_PUSH("tick");
int toTick = timer.ticks;
timer.ticks = 0;
for (int i = 0; i < toTick; ++i, ++ticks) tick(i, toTick-1);
TIMER_POP_PUSH("updatelights");
{
if (level && !isGeneratingLevel) {
level->updateLights();
}
}
TIMER_POP();
// Restart the server if (our modded) RakNet reports an error
if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
restartServer();
}
}
void Minecraft::restartServer() {
if (!level) return;
raknetInstance->resetIsBroken();
hostMultiplayer();
if (netCallback) netCallback->levelGenerated(level);
}
void Minecraft::tick(int nTick, int maxTick) {
if (missTime > 0) missTime--;
TIMER_PUSH("gameMode");
if (level) {
gameMode->tick();
}
TIMER_POP_PUSH("commandServer");
if (level && _commandServer) {
_commandServer->tick();
}
//
// Ongoing level generation in a (perhaps) different thread. When it's
// ready, _levelGenerated() is called once and any threads are deleted.
//
if (isGeneratingLevel) {
return;
} else if (!_hasSignaledGeneratingLevelFinished) {
if (generateLevelThread) {
delete generateLevelThread;
generateLevelThread = NULL;
}
_levelGenerated();
}
//
// Normal game loop, run before or efter level generation
//
if (level != NULL) {
TIMER_POP_PUSH("level");
level->tickEntities();
level->tick();
}
TIMER_POP();
}
bool Minecraft::isOnlineClient() {
return false;
}
bool Minecraft::isOnline() {
return netCallback != NULL;
}
void Minecraft::init()
{
// WHY DO WE NEED THIS ON MODERN PLATFORMS :sob:
// Global initialization goes here
Mth::initMth();
if (raknetInstance != nullptr) {
delete raknetInstance;
}
raknetInstance = new RakNetInstance();
// If we're running Android, only initialize
// the first time class is instanced
#ifdef ANDROID
if (!_hasInitedStatics) {
_hasInitedStatics = true;
#endif
Material::initMaterials();
MobCategory::initMobCategories();
Tile::initTiles();
Item::initItems();
Biome::initBiomes();
TileEntity::initTileEntities();
#ifdef ANDROID
}
#endif
setIsCreativeMode(false); // false means it's Survival Mode
#if !defined(NO_STORAGE)
storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
#else
storageSource = new MemoryLevelStorageSource();
#endif
// Server-only featire @todo server class app
hostMultiplayer();
}
//
// Multiplayer
//
void Minecraft::hostMultiplayer(int port) {
// Tear down last instance
raknetInstance->disconnect();
delete netCallback;
netCallback = nullptr;
#if !defined(NO_NETWORK)
netCallback = new ServerSideNetworkHandler(this, raknetInstance);
#endif
}
//
// Level generation
//
/*static*/
void* Minecraft::prepareLevel_tspawn(void *p_param) {
Minecraft* mc = (Minecraft*) p_param;
mc->generateLevel("Currently not used", mc->level);
return 0;
}
void Minecraft::generateLevel( const std::string& message, Level* level ) {
Stopwatch s;
s.start();
prepareLevel(message);
s.stop();
s.print("Level generated: ");
// "Unlock"
isGeneratingLevel = false;
}
void Minecraft::_levelGenerated() {
level->validateSpawn();
if (raknetInstance->isServer())
raknetInstance->announceServer(getServerName());
if (netCallback) {
netCallback->levelGenerated(level);
}
_hasSignaledGeneratingLevelFinished = true;
}
Player* Minecraft::respawnPlayer(int playerId) {
for (unsigned int i = 0; i < level->players.size(); ++i) {
if (level->players[i]->entityId == playerId) {
resetPlayer(level->players[i]);
return level->players[i];
}
}
return NULL;
}
void Minecraft::resetPlayer(Player* player) {
level->validateSpawn();
player->reset();
Pos p;
if(player->hasRespawnPosition()) {
p = player->getRespawnPosition();
}
else {
p = level->getSharedSpawnPos();
}
player->setPos((float)p.x + 0.5f, (float)p.y + 1.0f, (float)p.z + 0.5f);
player->resetPos(true);
if (isCreativeMode())
player->inventory->clearInventoryWithDefault();
}
int Minecraft::getProgressStatusId() {
return progressStageStatusId;
}
const char* Minecraft::getProgressMessage()
{
return progressMessages[progressStageStatusId];
}
bool Minecraft::isLevelGenerated()
{
return level != NULL && !isGeneratingLevel;
}
LevelStorageSource* Minecraft::getLevelSource()
{
return storageSource;
}
void Minecraft::setIsCreativeMode(bool isCreative)
{
#ifdef CREATORMODE
delete gameMode;
gameMode = new CreatorMode(this);
_isCreativeMode = true;
#else
if (!gameMode || isCreative != _isCreativeMode)
{
delete gameMode;
if (isCreative) gameMode = new CreativeMode(*this);
else gameMode = new SurvivalMode(*this);
_isCreativeMode = isCreative;
}
#endif
}
bool Minecraft::isCreativeMode() {
return _isCreativeMode;
}
ICreator* Minecraft::getCreator()
{
#ifdef CREATORMODE
return ((CreatorMode*)gameMode)->getCreator();
#else
return NULL;
#endif
}
void Minecraft::optionUpdated(OptionId option, bool value ) {
if(netCallback != NULL && option == OPTIONS_SERVER_VISIBLE) {
ServerSideNetworkHandler* ss = (ServerSideNetworkHandler*) netCallback;
ss->allowIncomingConnections(value);
}
}
void Minecraft::optionUpdated(OptionId option, float value ) {}
void Minecraft::optionUpdated(OptionId option, int value ) {}

140
src/Minecraft.h Executable file
View File

@@ -0,0 +1,140 @@
#ifndef NET_MINECRAFT_CLIENT__Minecraft_H__
#define NET_MINECRAFT_CLIENT__Minecraft_H__
#include "client/Options.h"
#include "client/Timer.h"
//#include "../network/RakNetInstance.h"
#include "world/phys/HitResult.h"
#include "App.h"
#include <cstddef>
class Level;
class LocalPlayer;
class IInputHolder;
class Mob;
class Player;
class Entity;
class ICreator;
class GameMode;
class CThread;
class LevelStorageSource;
class BuildActionIntention;
class PerfRenderer;
class LevelSettings;
class IRakNetInstance;
class NetEventCallback;
class CommandServer;
struct PingedCompatibleServer;
class Minecraft: public App {
public:
using App::App;
virtual ~Minecraft();
virtual void init();
virtual void update();
virtual void restartServer();
virtual void tick(int nTick, int maxTick);
virtual bool isOnlineClient();
virtual bool isOnline();
virtual void setIsCreativeMode(bool isCreative);
virtual void optionUpdated(OptionId option, bool value);
virtual void optionUpdated(OptionId option, float value);
virtual void optionUpdated(OptionId option, int value);
/**
* @brief Get public name that will be listed in JoinGame menu
*/
virtual std::string getServerName() { return "Unknown"; }
void toggleDimension() {}
bool isCreativeMode();
virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
virtual void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL);
virtual void onBlockDestroyed(Player* player, int x, int y, int z, int face) {}
void generateLevel( const std::string& message, Level* level );
LevelStorageSource* getLevelSource();
virtual void hostMultiplayer(int port=19132);
Player* respawnPlayer(int playerId);
void respawnPlayer();
void resetPlayer(Player* player);
void doActuallyRespawnPlayer();
void prepareLevel(const std::string& message);
int getProgressStatusId();
const char* getProgressMessage();
ICreator* getCreator();
bool isLevelGenerated();
#ifdef __APPLE__
bool _isSuperFast = false;
bool isSuperFast() { return _isSuperFast; }
#endif
protected:
virtual void _levelGenerated();
private:
static void* prepareLevel_tspawn(void *p_param);
public:
Level* level = nullptr;
CommandServer* _commandServer = nullptr;
GameMode* gameMode = nullptr;
IRakNetInstance* raknetInstance = nullptr;
NetEventCallback* netCallback = nullptr;
int commandPort = 4711;
int lastTime = 0;
int lastTickTime = -1;
int missTime = 0;
int ticks = 0;
CThread* generateLevelThread = nullptr;
// static int customDebugId;
HitResult hitResult;
volatile int progressStagePercentage = 0;
// This field is initialized in main()
// It sets the base path to where worlds can be written (sdcard on android)
std::string externalStoragePath;
std::string externalCacheStoragePath;
protected:
Timer timer{20};
// @note @attn @warn: this is dangerous as fuck!
volatile bool isGeneratingLevel = false;
bool _hasSignaledGeneratingLevelFinished = true;
LevelStorageSource* storageSource;
bool _running;
protected:
volatile int progressStageStatusId = 0;
static const char* progressMessages[];
int _licenseId;
bool _isCreativeMode;
Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
// from NinecraftApp
bool _verbose = true;
int _lastTickMs = 0;
static bool _hasInitedStatics;
};
#endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

1280
src/client/Minecraft.cpp → src/MinecraftClient.cpp Executable file → Normal file
View File

File diff suppressed because it is too large Load Diff

142
src/MinecraftClient.h Normal file
View File

@@ -0,0 +1,142 @@
#pragma once
#include "client/gui/Font.h"
#include "client/gui/Screen.h"
#include "client/particle/ParticleEngine.h"
#include "client/player/LocalPlayer.h"
#include "client/renderer/GameRenderer.h"
#include "client/renderer/Textures.h"
#include "client/sound/SoundEngine.h"
#include <Minecraft.h>
#include <client/MouseHandler.h>
#include <client/gui/Gui.h>
#include <client/gui/screens/ScreenChooser.h>
#include <client/PixelCalc.h>
#include <client/renderer/LevelRenderer.h>
class MinecraftClient : public Minecraft {
public:
using Minecraft::Minecraft;
~MinecraftClient();
void init() override;
void update() override;
void setSize(int width, int height);
void reloadOptions();
bool supportNonTouchScreen();
bool useTouchscreen();
void grabMouse();
void releaseMouse();
void setScreen(Screen*);
void leaveGame(bool renameLevel = false);
void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL) override;
void updateStats();
void restartServer() override;
bool handleBack(bool isDown) override;
void onGraphicsReset();
void initGLStates();
void tick(int nTick, int maxTick) override;
void tickInput();
void handleBuildAction(BuildActionIntention* action);
bool isOnlineClient() override;
void pauseGame(bool isBackPaused);
void gameLostFocus();
void respawnPlayer();
void audioEngineOn() override;
void audioEngineOff() override;
void setIsCreativeMode(bool isCreative) override;
void optionUpdated(OptionId option, bool value) override;
void optionUpdated(OptionId option, float value) override;
void optionUpdated(OptionId option, int value) override;
LocalPlayer* getPlayer() { return player; }
Font* getFont() { return font; }
Textures& textures() { return m_textures; }
Options& options() { return m_options;}
Screen* getScreen() { return m_screen; }
Gui& gui() { return m_gui; }
ParticleEngine* getParticleEngine() {return particleEngine; }
int getScreenWidth() { return width; }
int getScreenHeigth() { return height; }
virtual void hostMultiplayer(int port) override;
bool isPowerVR() { return _powerVr; }
bool isKindleFire(int kindleVersion);
bool transformResolution(int* w, int* h);
virtual std::string getServerName() override;
void locateMultiplayer();
void cancelLocateMultiplayer();
bool joinMultiplayer(const PingedCompatibleServer& server);
bool joinMultiplayerFromString(const std::string& server);
void onBlockDestroyed(Player* player, int x, int y, int z, int face) override;
protected:
void _reloadInput();
void _levelGenerated() override;
int width = 1, height = 1;
Font* font = nullptr;
// @warn This is unsafe cuz Gui may call some MinecraftClient method while MinecraftClient is not ready
MouseHandler mouseHandler;
LevelRenderer* levelRenderer = nullptr;
GameRenderer* gameRenderer = nullptr;
ParticleEngine* particleEngine = nullptr;
SoundEngine* soundEngine = nullptr;
PerfRenderer* _perfRenderer = nullptr;
bool mouseGrabbed = false;
PixelCalc pixelCalc;
PixelCalc pixelCalcUi;
Screen* m_screen = nullptr;
bool screenMutex = false;
bool hasScheduledScreen = false;
Screen* scheduledScreen = nullptr;
int m_frames = 0;
volatile bool pause = false;
// @todo make static
LocalPlayer* player = nullptr;
IInputHolder* inputHolder = nullptr;
Mob* cameraTargetPlayer = nullptr;
bool _supportsNonTouchscreen = false;
bool isLookingForMultiplayer = false;
bool _powerVr = false;
Options m_options{*this};
Textures m_textures{m_options, *m_platform};
ScreenChooser screenChooser{*this};
Gui m_gui{*this};
};

15
src/MinecraftServer.cpp Normal file
View File

@@ -0,0 +1,15 @@
#include "MinecraftServer.h"
#include <Minecraft.h>
#include <network/RakNetInstance.h>
void MinecraftServer::hostMultiplayer(int port) {
Minecraft::hostMultiplayer(port);
raknetInstance->host("Server", port, 16);
}
std::string MinecraftServer::getServerName() {
// @todo read server name from config
return "Dedicated server 0.6.1";
}

10
src/MinecraftServer.h Normal file
View File

@@ -0,0 +1,10 @@
#pragma once
#include <Minecraft.h>
class MinecraftServer : public Minecraft {
public:
using Minecraft::Minecraft;
void hostMultiplayer(int port) override;
std::string getServerName() override;
};

428
src/NinecraftApp.cpp
View File

@@ -1,428 +0,0 @@
#include "NinecraftApp.h"
//#include <EGL/egl.h>
#ifdef RPI
//#define NO_STORAGE
#endif
#include <errno.h>
#include "platform/input/Mouse.h"
#include "platform/input/Multitouch.h"
#include "world/item/Item.h"
#include "world/level/Level.h"
#include "world/level/biome/Biome.h"
#include "world/level/material/Material.h"
#include "world/entity/MobCategory.h"
//#include "world/level/storage/FolderMethods.h"
#ifndef STANDALONE_SERVER
#include "client/gui/screens/StartMenuScreen.h"
#include "client/gui/screens/UsernameScreen.h"
#endif
#include "client/player/LocalPlayer.h"
#ifndef STANDALONE_SERVER
#include "client/renderer/gles.h"
#include "client/renderer/Chunk.h"
#include "client/renderer/LevelRenderer.h"
#include "client/renderer/Tesselator.h"
#endif
// sorry for raknet dependency, but I'm too lazy to find another getTime method
#include "raknet/GetTime.h"
#include "network/RakNetInstance.h"
#include "network/ClientSideNetworkHandler.h"
#include "client/gui/screens/ProgressScreen.h"
//#include "world/entity/player/Inventory2.h"
#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
#include "world/level/storage/ExternalFileLevelStorageSource.h"
#else
#include "world/level/storage/MemoryLevelStorageSource.h"
#endif
#ifndef STANDALONE_SERVER
#include "client/renderer/Textures.h"
#include "client/renderer/entity/ItemRenderer.h"
#endif
#include "world/item/crafting/Recipes.h"
#include "world/level/tile/entity/TileEntity.h"
#ifndef STANDALONE_SERVER
#include "client/renderer/EntityTileRenderer.h"
#endif
bool NinecraftApp::_hasInitedStatics = false;
NinecraftApp::NinecraftApp()
: _verbose(true),
_lastTickMs(0),
_frames(0)
{
#if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
signal(SIGPIPE, SIG_IGN);
#endif
}
NinecraftApp::~NinecraftApp()
{
teardown();
}
void NinecraftApp::init()
{
// Global initialization goes here
Mth::initMth();
//#ifdef DEMO_MODE
//writeDemoFile();
//#endif
// If we're running Android, only initialize
// the first time class is instanced
#ifdef ANDROID
if (!_hasInitedStatics) {
_hasInitedStatics = true;
#endif
Material::initMaterials();
MobCategory::initMobCategories();
Tile::initTiles();
Item::initItems();
Biome::initBiomes();
TileEntity::initTileEntities();
#ifdef ANDROID
}
#endif
#ifndef STANDALONE_SERVER
initGLStates();
Tesselator::instance.init();
I18n::loadLanguage(platform(), "en_US");
#endif
if (!externalStoragePath.empty()) {
options.setOptionsFilePath(externalStoragePath);
}
Minecraft::init();
#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
#else
storageSource = new MemoryLevelStorageSource();
#endif
_running = false;
#ifndef STANDALONE_SERVER
LOGI("This: %p\n", this);
screenChooser.setScreen(SCREEN_STARTMENU);
if (options.getBooleanValue(OPTIONS_FIRST_LAUNCH)) {
options.toggle(OPTIONS_FIRST_LAUNCH);
setScreen(new UsernameScreen());
}
#else
hostMultiplayer();
#endif
}
void NinecraftApp::teardown()
{
// Note: Don't tear down statics if we run on Android
// (we might change this in the future)
#ifndef ANDROID
Biome::teardownBiomes();
Item ::teardownItems();
Tile ::teardownTiles();
Material::teardownMaterials();
Recipes ::teardownRecipes();
TileEntity::teardownTileEntities();
#endif
#ifdef WIN32
ItemRenderer::teardown_static();
if (EntityTileRenderer::instance != NULL) {
delete EntityTileRenderer::instance;
EntityTileRenderer::instance = NULL;
}
TileEntityRenderDispatcher::destroy();
#endif
}
void NinecraftApp::update()
{
++_frames;
// Generate Multitouch active pointer list
Multitouch::commit();
#ifndef ANDROID_PUBLISH
//testCreationAndDestruction();
//testJoiningAndDestruction();
#endif /*ANDROID_PUBLISH*/
Minecraft::update();
swapBuffers();
Mouse::reset2();
// Restart the server if (our modded) RakNet reports an error
if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
restartServer();
}
#ifndef WIN32
updateStats();
#endif
}
void NinecraftApp::updateStats()
{
#ifndef STANDALONE_SERVER
if (Options::debugGl)
LOGI("--------------------------------------------\n");
//*
int now = getTimeMs();
//int since = now - _lastTickMs;
if (now >= lastTime + 1000)
{
if (player) {
LOGI("%d fps \t%3d chunk updates. (%.2f, %.2f, %.2f)\n",
_frames, Chunk::updates, player->x, player->y, player->z);
Chunk::resetUpdates();
//static int _n = 0;
//if (++_n % 5 == -1) { // @note: -1
// static char filename[256];
// sprintf(filename, "%s/games/com.mojang/img_%.4d.jpg", externalStoragePath.c_str(), _n/5);
// _context.platform->saveScreenshot(filename, width, height);
//}
LOGI("%s", levelRenderer->gatherStats1().c_str());
//printf("Texture swaps (this frame): %d\n", Textures::textureChanges);
} else {
LOGI("%d fps\n", _frames);
}
//const int* pointerIds;
//int pointerCount = Multitouch::getActivePointerIds(&pointerIds);
//if (pointerCount) {
// std::string s = "Pointers (";
// s += (char)(48 + pointerCount);
// s += ": ";
// for (int i = 0; i < pointerCount; ++i) {
// s += (char)(48 + pointerIds[i]);
// s += ", ";
// }
// LOGI("%s\n", s.c_str());
//}
lastTime = now;
_frames = 0;
#ifdef GLDEBUG
while (1) {
int error = glGetError();
if (error == GL_NO_ERROR) break;
LOGI("#################### GL-ERROR: %d\t#####################\n", error);
LOGI("#################### GL-ERROR: %d\t#####################\n", error);
LOGI("#################### GL-ERROR: %d\t#####################\n", error);
}
#endif
}
Textures::textureChanges = 0;
/**/
#endif /* STANDALONE_SERVER */
}
void NinecraftApp::initGLStates()
{
#ifndef STANDALONE_SERVER
//glShadeModel2(GL_SMOOTH);
//glClearDepthf(1.0f);
glEnable2(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthRangef(0, 1);
glEnable2(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.1f);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glEnable2(GL_TEXTURE_2D);
#ifndef _EMSCRIPTEN_
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
#endif
// Both updates isPowerVR flag in java and returns if the graphics chip is PowerVR SGX or not
_powerVr = platform()->isPowerVR();
#ifdef __APPLE__
_isSuperFast = platform()->isSuperFast();
#endif
//glLineWidth(4);
#endif /* STANDALONE_SERVER */
}
void NinecraftApp::restartServer() {
if (!level) return;
for (int i = level->players.size()-1; i >= 0; --i) {
Player* p = level->players[i];
if (p != player)
level->removeEntity(p);
}
raknetInstance->resetIsBroken();
#ifndef STANDALONE_SERVER
gui.addMessage("This server has restarted!");
#endif
hostMultiplayer();
if (netCallback) netCallback->levelGenerated(level);
}
bool NinecraftApp::handleBack(bool isDown)
{
if (isGeneratingLevel)
{
return true;
}
if (level)
{
if (!isDown)
{
if (screen)
{
if (!screen->handleBackEvent(isDown))
{
if (player->containerMenu) player->closeContainer();
setScreen(NULL);
}
return true;
} else {
pauseGame(true);
}
//leaveGame();
return false;
}
return true;
}
else if (screen)
{
return screen->handleBackEvent(isDown);
}
return false;
}
void NinecraftApp::onGraphicsReset()
{
#ifndef STANDALONE_SERVER
initGLStates();
Tesselator::instance.init();
Minecraft::onGraphicsReset();
#endif
}
#ifndef ANDROID_PUBLISH
static int _state = -1;
static int _stateTicksLeft = 0;
void NinecraftApp::testCreationAndDestruction()
{
if (_state == -1) {
_stateTicksLeft = 100;
_state = 0;
}
if (_state == 0) {
if (--_stateTicksLeft <= 0)
_state = 1;
}
else if (_state == 1) {
getLevelSource()->deleteLevel("perf");
int seed = getEpochTimeS();
LOGI(">seed %d\n", seed);
selectLevel("perf", "perf", LevelSettings(seed, GameType::Creative));
hostMultiplayer();
#ifndef STANDALONE_SERVER
setScreen(new ProgressScreen());
#endif
_state = 2;
_stateTicksLeft = 1000;//25000;//00;
}
else if (_state == 2) {
if (isLevelGenerated()) {
if (--_stateTicksLeft <= 0) {
_state = 3;
}
}
} else if (_state == 3) {
leaveGame();
_state = 1;
}
}
void NinecraftApp::testJoiningAndDestruction()
{
if (_state == -1) {
//LightUpdate sz[2] = { LightUpdate(LightLayer::Block, 0, 0, 0, 1, 1, 1),
// LightUpdate(LightLayer::Sky, 0, 0, 0, 1, 1, 1) };
//LOGI("size of lightupdate: %lu == %d\n", sizeof(LightUpdate), (const char*)&sz[1] - (const char*)&sz[0]);
_stateTicksLeft = 100;
_state = 0;
}
if (_state == 0) {
if (--_stateTicksLeft <= 0) {
raknetInstance->clearServerList();
locateMultiplayer();
_state = 1;
}
}
else if (_state == 1) {
if (!raknetInstance->getServerList().empty()) {
PingedCompatibleServer s = raknetInstance->getServerList().at(0);
if (s.name.GetLength() > 0) {
joinMultiplayer(s);
#ifndef STANDALONE_SERVER
setScreen(new ProgressScreen());
#endif
_state = 2;
_stateTicksLeft = 80;//1000;
}
}
}
else if (_state == 2) {
if (isLevelGenerated()) {
if (--_stateTicksLeft <= 0) {
_state = 3;
}
}
} else if (_state == 3) {
leaveGame();
_stateTicksLeft = 50;
_state = 0;
}
}
#endif /*ANDROID_PUBLISH*/
/*
void NinecraftApp::writeDemoFile() {
std::string path = externalStoragePath + "/games";
if (createFolderIfNotExists(path.c_str())) {
path += "/com.mojang";
if (createFolderIfNotExists(path.c_str())) {
path += "/minecraftpe";
if (createFolderIfNotExists(path.c_str())) {
path += "/played_demo";
FILE* fp = fopen(path.c_str(), "w");
if (fp) fclose(fp);
}}}
}
bool NinecraftApp::hasPlayedDemo() {
std::string filename = externalStoragePath + "/games/com.mojang/minecraftpe/played_demo";
FILE* fp = fopen(filename.c_str(), "r");
if (!fp) return false;
fclose(fp);
return true;
}
*/

52
src/NinecraftApp.h
View File

@@ -1,52 +0,0 @@
#ifndef NINECRAFTAPP_H__
#define NINECRAFTAPP_H__
#include "world/Pos.h"
#include "App.h"
#include "client/Minecraft.h"
#include "world/level/storage/MemoryLevelStorage.h"
#include <string>
class Level;
class LocalPlayer;
class ExternalFileLevelStorageSource;
class NinecraftApp: public Minecraft
{
public:
NinecraftApp();
~NinecraftApp();
void init();
void teardown();
void update();
virtual bool handleBack(bool isDown);
protected:
void onGraphicsReset();
private:
void initGLStates();
void restartServer();
void updateStats();
//void writeDemoFile();
//bool hasPlayedDemo();
#ifndef ANDROID_PUBLISH
void testCreationAndDestruction();
void testJoiningAndDestruction();
#endif /*ANDROID_PUBLISH*/
bool _verbose;
int _frames;
int _lastTickMs;
static bool _hasInitedStatics;
};
#endif//NINECRAFTAPP_H__

229
src/client/Minecraft.h
View File

@@ -1,229 +0,0 @@
#ifndef NET_MINECRAFT_CLIENT__Minecraft_H__
#define NET_MINECRAFT_CLIENT__Minecraft_H__
#include "Options.h"
#ifndef STANDALONE_SERVER
#include "MouseHandler.h"
#include "gui/Gui.h"
#include "gui/screens/ScreenChooser.h"
#endif
#include "Timer.h"
//#include "../network/RakNetInstance.h"
#include "../world/phys/HitResult.h"
class Level;
class LocalPlayer;
class IInputHolder;
class Mob;
class Player;
class LevelRenderer;
class GameRenderer;
class ParticleEngine;
class Entity;
class ICreator;
class GameMode;
class Textures;
class CThread;
class SoundEngine;
class Screen;
class Font;
class LevelStorageSource;
class BuildActionIntention;
class PerfRenderer;
class LevelSettings;
class IRakNetInstance;
class NetEventCallback;
class CommandServer;
struct PingedCompatibleServer;
//class ExternalFileLevelStorageSource;
#include "../App.h"
#include "PixelCalc.h"
class AppPlatform;
class AppPlatform_android;
class Minecraft: public App
{
protected:
Minecraft();
public:
virtual ~Minecraft();
void init();
void setSize(int width, int height);
void reloadOptions();
bool supportNonTouchScreen();
bool useTouchscreen();
void grabMouse();
void releaseMouse();
void handleBuildAction(BuildActionIntention*);
void toggleDimension(){}
bool isCreativeMode();
void setIsCreativeMode(bool isCreative);
void setScreen(Screen*);
virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
virtual void setLevel(Level* level, const std::string& message = "", LocalPlayer* forceInsertPlayer = NULL);
void generateLevel( const std::string& message, Level* level );
LevelStorageSource* getLevelSource();
bool isLookingForMultiplayer;
void locateMultiplayer();
void cancelLocateMultiplayer();
bool joinMultiplayer(const PingedCompatibleServer& server);
bool joinMultiplayerFromString(const std::string& server);
void hostMultiplayer(int port=19132);
Player* respawnPlayer(int playerId);
void respawnPlayer();
void resetPlayer(Player* player);
void doActuallyRespawnPlayer();
void update();
void tick(int nTick, int maxTick);
void tickInput();
bool isOnlineClient();
bool isOnline();
void pauseGame(bool isBackPaused);
void gameLostFocus();
void prepareLevel(const std::string& message);
void leaveGame(bool renameLevel = false);
int getProgressStatusId();
const char* getProgressMessage();
ICreator* getCreator();
// void onGraphicsLost() {}
void onGraphicsReset();
bool isLevelGenerated();
void handleMouseDown(int button, bool down);
void audioEngineOn();
void audioEngineOff();
bool isPowerVR() { return _powerVr; }
bool isKindleFire(int kindleVersion);
bool transformResolution(int* w, int* h);
void optionUpdated(OptionId option, bool value);
void optionUpdated(OptionId option, float value);
void optionUpdated(OptionId option, int value);
#ifdef __APPLE__
bool _isSuperFast;
bool isSuperFast() { return _isSuperFast; }
#endif
protected:
void _levelGenerated();
private:
static void* prepareLevel_tspawn(void *p_param);
void _reloadInput();
public:
int width;
int height;
// Vars that the platform is allowed to use in the future
int commandPort;
int reserved_d1, reserved_d2;
float reserved_f1, reserved_f2;
Options options;
static bool useAmbientOcclusion;
//static bool threadInterrupt;
volatile bool pause;
LevelRenderer* levelRenderer;
GameRenderer* gameRenderer;
ParticleEngine* particleEngine;
SoundEngine* soundEngine;
GameMode* gameMode;
#ifndef STANDALONE_SERVER
Textures* textures;
ScreenChooser screenChooser;
Font* font;
#endif
IRakNetInstance* raknetInstance;
NetEventCallback* netCallback;
int lastTime;
int lastTickTime;
float ticksSinceLastUpdate;
Level* level;
LocalPlayer* player;
IInputHolder* inputHolder;
Mob* cameraTargetPlayer;
#ifndef STANDALONE_SERVER
Gui gui;
#endif
CThread* generateLevelThread;
Screen* screen;
static int customDebugId;
static const int CDI_NONE = 0;
static const int CDI_GRAPHICS = 1;
#ifndef STANDALONE_SERVER
MouseHandler mouseHandler;
#endif
bool mouseGrabbed;
PixelCalc pixelCalc;
PixelCalc pixelCalcUi;
HitResult hitResult;
volatile int progressStagePercentage;
// This field is initialized in main()
// It sets the base path to where worlds can be written (sdcard on android)
std::string externalStoragePath;
std::string externalCacheStoragePath;
protected:
Timer timer;
// @note @attn @warn: this is dangerous as fuck!
volatile bool isGeneratingLevel;
bool _hasSignaledGeneratingLevelFinished;
LevelStorageSource* storageSource;
bool _running;
bool _powerVr;
private:
volatile int progressStageStatusId;
static const char* progressMessages[];
int missTime;
int ticks;
bool screenMutex;
bool hasScheduledScreen;
Screen* scheduledScreen;
int _licenseId;
bool _supportsNonTouchscreen;
bool _isCreativeMode;
//int _respawnPlayerTicks;
Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
PerfRenderer* _perfRenderer;
CommandServer* _commandServer;
};
#endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

13
src/client/Options.cpp
View File

@@ -1,11 +1,6 @@
#include "Options.h"
#include "OptionStrings.h"
#include "Minecraft.h"
#include "../platform/log.h"
#include "../world/Difficulty.h"
#include <cmath>
#include <memory>
#include <MinecraftClient.h>
bool Options::debugGl = false;
@@ -290,13 +285,13 @@ void Options::setOptionsFilePath(const std::string& path) {
}
void Options::notifyOptionUpdate(OptionId key, bool value) {
minecraft->optionUpdated(key, value);
minecraft.optionUpdated(key, value);
}
void Options::notifyOptionUpdate(OptionId key, float value) {
minecraft->optionUpdated(key, value);
minecraft.optionUpdated(key, value);
}
void Options::notifyOptionUpdate(OptionId key, int value) {
minecraft->optionUpdated(key, value);
minecraft.optionUpdated(key, value);
}

11
src/client/Options.h
View File

@@ -15,9 +15,8 @@
//#include "locale/Language.h"
#include <string>
#include <cstdio>
#include "../platform/input/Keyboard.h"
#include "../util/StringUtils.h"
#include <platform/input/Keyboard.h>
#include <util/StringUtils.h>
#include "OptionsFile.h"
#include "Option.h"
#include <array>
@@ -88,7 +87,7 @@ enum OptionId {
OPTIONS_COUNT
};
class Minecraft;
class MinecraftClient;
typedef std::vector<std::string> StringVector;
class Options
@@ -96,7 +95,7 @@ class Options
public:
static bool debugGl;
Options(Minecraft* minecraft, const std::string& workingDirectory = "")
Options(MinecraftClient& minecraft, const std::string& workingDirectory = "")
: minecraft(minecraft) {
// elements werent initialized so i was getting a garbage pointer and a crash
m_options.fill(nullptr);
@@ -161,7 +160,7 @@ private:
std::array<Option*, OPTIONS_COUNT> m_options;
OptionsFile optionsFile;
Minecraft* minecraft;
MinecraftClient& minecraft;
};
#endif /*NET_MINECRAFT_CLIENT__Options_H__*/

56
src/client/gamemode/CreativeMode.cpp
View File

@@ -1,56 +0,0 @@
#include "CreativeMode.h"
#include "../Minecraft.h"
#ifndef STANDALONE_SERVER
#include "../particle/ParticleEngine.h"
#endif
#include "../player/LocalPlayer.h"
#ifndef STANDALONE_SERVER
#include "../renderer/LevelRenderer.h"
#include "../sound/SoundEngine.h"
#endif
#include "../../world/level/Level.h"
//#include "../../network/Packet.h"
#include "../../network/packet/RemoveBlockPacket.h"
#include "../../world/entity/player/Abilities.h"
static const int DestructionTickDelay = 5;
CreativeMode::CreativeMode(Minecraft* minecraft)
: super(minecraft)
{
}
void CreativeMode::startDestroyBlock(int x, int y, int z, int face) {
if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
return;
creativeDestroyBlock(x, y, z, face);
destroyDelay = DestructionTickDelay;
}
void CreativeMode::creativeDestroyBlock(int x, int y, int z, int face) {
minecraft->level->extinguishFire(x, y, z, face);
destroyBlock(x, y, z, face);
}
void CreativeMode::continueDestroyBlock(int x, int y, int z, int face) {
destroyDelay--;
if (destroyDelay <= 0) {
destroyDelay = DestructionTickDelay;
creativeDestroyBlock(x, y, z, face);
}
}
void CreativeMode::stopDestroyBlock() {
destroyDelay = 0;
}
void CreativeMode::initAbilities( Abilities& abilities ) {
abilities.mayfly = true;
abilities.instabuild = true;
abilities.invulnerable = true;
}
bool CreativeMode::isCreativeType() {
return true;
}

102
src/client/gamemode/CreatorMode.cpp
View File

@@ -1,102 +0,0 @@
#include "CreatorMode.h"
#include "../Minecraft.h"
#include "../particle/ParticleEngine.h"
#include "../player/LocalPlayer.h"
#include "../renderer/LevelRenderer.h"
#include "../sound/SoundEngine.h"
#include "../../world/level/Level.h"
//#include "../../network/Packet.h"
#include "../../network/packet/RemoveBlockPacket.h"
#include "../../world/entity/player/Abilities.h"
static const int DestructionTickDelay = 5;
class Creator: public ICreator {
//virtual void getEvents();
public:
Creator(/*int eventLifeTime*/)
: _tileEvents(32),
_tickId(0)
{
}
void setTick(int tick) {
_tickId = tick;
}
EventList<TileEvent>& getTileEvents() { return _tileEvents; }
void addevent_blockUse(int entityId, int x, int y, int z, int face) {
TileEvent t = {
entityId,
x,y,z,
face
};
_tileEvents.add(t, _tickId);
}
private:
EventList<TileEvent> _tileEvents;
int _tickId;
};
CreatorMode::CreatorMode(Minecraft* minecraft)
: super(minecraft)
{
_creator = new Creator();
}
CreatorMode::~CreatorMode() {
delete _creator;
}
void CreatorMode::startDestroyBlock(int x, int y, int z, int face) {
if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
return;
CreatorDestroyBlock(x, y, z, face);
destroyDelay = DestructionTickDelay;
}
void CreatorMode::CreatorDestroyBlock(int x, int y, int z, int face) {
minecraft->level->extinguishFire(x, y, z, face);
destroyBlock(x, y, z, face);
}
void CreatorMode::continueDestroyBlock(int x, int y, int z, int face) {
destroyDelay--;
if (destroyDelay <= 0) {
destroyDelay = DestructionTickDelay;
CreatorDestroyBlock(x, y, z, face);
}
}
bool CreatorMode::useItemOn( Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit ) {
if (item && item->id == ((Item*)Item::sword_iron)->id)
_creator->addevent_blockUse(player->entityId, x, y, z, face);
return super::useItemOn(player, level, item, x, y, z, face, hit);
}
void CreatorMode::stopDestroyBlock() {
destroyDelay = 0;
}
void CreatorMode::initAbilities( Abilities& abilities ) {
abilities.mayfly = true;
abilities.instabuild = true;
abilities.invulnerable = true;
}
bool CreatorMode::isCreativeType() {
return true;
}
ICreator* CreatorMode::getCreator() {
return _creator;
}
void CreatorMode::tick() {
_creator->setTick(minecraft->level->getTime());
super::tick();
}

98
src/client/gamemode/SurvivalMode.cpp
View File

@@ -1,98 +0,0 @@
#include "SurvivalMode.h"
#include "../Minecraft.h"
#include "../player/LocalPlayer.h"
#ifndef STANDALONE_SERVER
#include "../particle/ParticleEngine.h"
#include "../sound/SoundEngine.h"
#endif
#include "../../world/level/Level.h"
#include "../../world/entity/player/Abilities.h"
SurvivalMode::SurvivalMode( Minecraft* minecraft )
: super(minecraft),
xDestroyBlock(-1),
yDestroyBlock(-1),
zDestroyBlock(-1)
{
}
void SurvivalMode::continueDestroyBlock( int x, int y, int z, int face ) {
if (destroyDelay > 0) {
destroyDelay--;
return;
}
if (x == xDestroyBlock && y == yDestroyBlock && z == zDestroyBlock) {
int t = minecraft->level->getTile(x, y, z);
if (t == 0) return;
Tile* tile = Tile::tiles[t];
destroyProgress += tile->getDestroyProgress(minecraft->player);
if ((++destroyTicks & 3) == 1) {
#ifndef STANDALONE_SERVER
if (tile != NULL) {
minecraft->soundEngine->play(tile->soundType->getStepSound(), x + 0.5f, y + 0.5f, z + 0.5f, (tile->soundType->getVolume() + 1) / 8, tile->soundType->getPitch() * 0.5f);
}
#endif
}
if (destroyProgress >= 1) {
destroyBlock(x, y, z, face);
destroyProgress = 0;
oDestroyProgress = 0;
destroyTicks = 0;
destroyDelay = 5;
}
} else {
destroyProgress = 0;
oDestroyProgress = 0;
destroyTicks = 0;
xDestroyBlock = x;
yDestroyBlock = y;
zDestroyBlock = z;
}
}
bool SurvivalMode::destroyBlock( int x, int y, int z, int face ) {
int t = minecraft->level->getTile(x, y, z);
int data = minecraft->level->getData(x, y, z);
bool changed = GameMode::destroyBlock(x, y, z, face);
bool couldDestroy = minecraft->player->canDestroy(Tile::tiles[t]);
ItemInstance* item = minecraft->player->inventory->getSelected();
if (item != NULL) {
item->mineBlock(t, x, y, z);
if (item->count == 0) {
//item->snap(minecraft->player);
minecraft->player->inventory->clearSlot(minecraft->player->inventory->selected);
}
}
if (changed && couldDestroy) {
ItemInstance instance(t, 1, data);
Tile::tiles[t]->playerDestroy(minecraft->level, minecraft->player, x, y, z, data);
}
return changed;
}
void SurvivalMode::stopDestroyBlock() {
destroyProgress = 0;
destroyDelay = 0;
}
void SurvivalMode::initAbilities( Abilities& abilities ) {
abilities.flying = false;
abilities.mayfly = false;
abilities.instabuild = false;
abilities.invulnerable = false;
}
void SurvivalMode::startDestroyBlock( int x, int y, int z, int face ) {
if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
return;
int t = minecraft->level->getTile(x, y, z);
if (t > 0 && destroyProgress == 0) Tile::tiles[t]->attack(minecraft->level, x, y, z, minecraft->player);
if (t > 0 && Tile::tiles[t]->getDestroyProgress(minecraft->player) >= 1)
destroyBlock(x, y, z, face);
}

50
src/client/gui/Gui.cpp
View File

@@ -1,11 +1,12 @@
#include "Gui.h"
#include "Font.h"
#include "MinecraftClient.h"
#include "client/Options.h"
#include "platform/input/Keyboard.h"
#include "screens/IngameBlockSelectionScreen.h"
#include "screens/ChatScreen.h"
#include "screens/ConsoleScreen.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../player/LocalPlayer.h"
#include "../renderer/Tesselator.h"
#include "../renderer/TileRenderer.h"
@@ -29,39 +30,23 @@
#include <algorithm>
#include <sstream>
#define MAX_MESSAGE_WIDTH 240
float Gui::InvGuiScale = 1.0f / 3.0f;
float Gui::GuiScale = 1.0f / Gui::InvGuiScale;
const float Gui::DropTicks = 40.0f;
//#include <android/log.h>
Gui::Gui(Minecraft* minecraft)
: minecraft(minecraft),
tickCount(0),
progress(0),
overlayMessageTime(0),
animateOverlayMessageColor(false),
chatScrollOffset(0),
tbr(1),
_inventoryNeedsUpdate(true),
_flashSlotId(-1),
_flashSlotStartTime(-1),
_slotFont(NULL),
_numSlots(4),
_currentDropTicks(-1),
_currentDropSlot(-1),
MAX_MESSAGE_WIDTH(240),
itemNameOverlayTime(2),
_openInventorySlot(minecraft->useTouchscreen())
{
// @todo virtual controlConfigurationChanged() when player switches from keyboard to touch for example
Gui::Gui(MinecraftClient& minecraft) : minecraft(minecraft), _openInventorySlot(minecraft.useTouchscreen()) {
glGenBuffers2(1, &_inventoryRc.vboId);
glGenBuffers2(1, &rcFeedbackInner.vboId);
glGenBuffers2(1, &rcFeedbackOuter.vboId);
//Gui::InvGuiScale = 1.0f / (int) (3 * Minecraft::width / 854);
}
Gui::~Gui()
{
Gui::~Gui() {
if (_slotFont)
delete _slotFont;
@@ -69,17 +54,16 @@ Gui::~Gui()
}
void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
if (!minecraft->level || !minecraft->player)
if (!minecraft.level || !minecraft.getPlayer())
return;
//minecraft->gameRenderer->setupGuiScreen();
Font* font = minecraft->font;
Font* font = minecraft.getFont();
const bool isTouchInterface = minecraft->useTouchscreen();
const bool isTouchInterface = minecraft.useTouchscreen();
const int screenWidth = (int)(minecraft->width * InvGuiScale);
const int screenHeight = (int)(minecraft->height * InvGuiScale);
const int screenWidth = (int)(minecraft.getScreenWidth() * InvGuiScale);
const int screenHeight = (int)(minecraft.getScreenHeigth() * InvGuiScale);
blitOffset = -90;
renderProgressIndicator(isTouchInterface, screenWidth, screenHeight, a);
@@ -91,9 +75,9 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
// F: 3
int ySlot = screenHeight - 16 - 3;
if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
if (minecraft->gameMode->canHurtPlayer()) {
minecraft->textures->loadAndBindTexture("gui/icons.png");
if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
if (minecraft.gameMode->canHurtPlayer()) {
minecraft.getTextures()->loadAndBindTexture("gui/icons.png");
Tesselator& t = Tesselator::instance;
t.beginOverride();
t.colorABGR(0xffffffff);
@@ -103,7 +87,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
}
}
if(minecraft->player->getSleepTimer() > 0) {
if(minecraft.getPlayer()->getSleepTimer() > 0) {
glDisable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
@@ -112,7 +96,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
glEnable(GL_ALPHA_TEST);
glEnable(GL_DEPTH_TEST);
}
if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
renderToolBar(a, ySlot, screenWidth);
glEnable(GL_BLEND);

35
src/client/gui/Gui.h
View File

@@ -10,7 +10,7 @@
#include "../../util/Random.h"
#include "../IConfigListener.h"
class Minecraft;
class MinecraftClient;
class ItemInstance;
class Textures;
class Tesselator;
@@ -27,7 +27,7 @@ typedef std::vector<GuiMessage> GuiMessageList;
class Gui: public GuiComponent, IConfigListener
{
public:
Gui(Minecraft* minecraft);
Gui(MinecraftClient& minecraft);
~Gui();
int getSlotIdAt(int x, int y);
@@ -90,43 +90,42 @@ private:
void tickItemDrop();
float cubeSmoothStep(float percentage, float min, float max);
public:
float progress;
float progress = 0.f;
std::string selectedName;
static float InvGuiScale;
static float GuiScale;
private:
int MAX_MESSAGE_WIDTH;
//ItemRenderer itemRenderer;
GuiMessageList guiMessages;
int chatScrollOffset;
int chatScrollOffset = 0;
Random random;
Minecraft* minecraft;
int tickCount;
float itemNameOverlayTime;
MinecraftClient& minecraft;
int tickCount = 0;
float itemNameOverlayTime = 2;
std::string overlayMessageString;
int overlayMessageTime;
bool animateOverlayMessageColor;
int overlayMessageTime = 0;
bool animateOverlayMessageColor = false;
float tbr;
float tbr = 1.f;
RenderChunk _inventoryRc;
bool _inventoryNeedsUpdate;
bool _inventoryNeedsUpdate = true;
int _flashSlotId;
float _flashSlotStartTime;
int _flashSlotId = -1;
float _flashSlotStartTime = -1;
Font* _slotFont;
int _numSlots;
Font* _slotFont = nullptr;
int _numSlots = 4;
RenderChunk rcFeedbackOuter;
RenderChunk rcFeedbackInner;
// For dropping
static const float DropTicks;
float _currentDropTicks;
int _currentDropSlot;
float _currentDropTicks = -1;
int _currentDropSlot = -1;
bool _openInventorySlot;
};

2
src/client/gui/Screen.cpp
View File

@@ -1,7 +1,7 @@
#include "Screen.h"
#include "components/Button.h"
#include "components/TextBox.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../renderer/Tesselator.h"
#include "../sound/SoundEngine.h"
#include "../../platform/input/Keyboard.h"

8
src/client/gui/components/RolledSelectionListH.cpp
View File

@@ -1,14 +1,14 @@
#include "RolledSelectionListH.h"
#include "../../Minecraft.h"
#include "../../renderer/Tesselator.h"
#include "../../renderer/gles.h"
#include "../../../platform/input/Mouse.h"
#include "../../../platform/input/Multitouch.h"
#include "../../../util/Mth.h"
#include "../../renderer/Textures.h"
#include "MinecraftClient.h"
RolledSelectionListH::RolledSelectionListH( Minecraft* minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
RolledSelectionListH::RolledSelectionListH( MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
: minecraft(minecraft),
width(width),
height(height),
@@ -172,7 +172,7 @@ void RolledSelectionListH::render( int xm, int ym, float a )
//LOGI("x: %f\n", xo);
minecraft->textures->loadAndBindTexture("gui/background.png");
minecraft.textures().loadAndBindTexture("gui/background.png");
glColor4f2(1.0f, 1, 1, 1);
float s = 32;
t.begin();
@@ -280,7 +280,7 @@ void RolledSelectionListH::render( int xm, int ym, float a )
void RolledSelectionListH::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
{
Tesselator& t = Tesselator::instance;
minecraft->textures->loadAndBindTexture("gui/background.png");
minecraft.textures().loadAndBindTexture("gui/background.png");
glColor4f2(1.0f, 1, 1, 1);
float s = 32;
t.begin();

6
src/client/gui/components/RolledSelectionListH.h
View File

@@ -2,7 +2,7 @@
#define NET_MINECRAFT_CLIENT_GUI_COMPONENTS__RolledSelectionListH_H__
#include "../GuiComponent.h"
class Minecraft;
class MinecraftClient;
class Tesselator;
@@ -12,7 +12,7 @@ class RolledSelectionListH : public GuiComponent
static const int DRAG_OUTSIDE = -2;
static const int DRAG_NORMAL = 0;
public:
RolledSelectionListH(Minecraft* minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth);
RolledSelectionListH(MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth);
virtual int getItemAtPosition(int x, int y);
@@ -45,7 +45,7 @@ protected:
virtual void clickedHeader(int headerMouseX, int headerMouseY) {}
int getItemAtXPositionRaw(int x);
protected:
Minecraft* minecraft;
MinecraftClient& minecraft;
float x0;
float x1;

2
src/client/gui/screens/ChestScreen.cpp
View File

@@ -22,7 +22,7 @@
//static NinePatchLayer* guiPaneFrame = NULL;
static __inline void setIfNotSet(bool& ref, bool condition) {
static inline void setIfNotSet(bool& ref, bool condition) {
ref = (ref || condition);
}

2
src/client/gui/screens/IngameBlockSelectionScreen.cpp
View File

@@ -9,7 +9,7 @@
#include "../Gui.h"
#include "../../renderer/Textures.h"
#include "../../gamemode/GameMode.h"
#include <gamemode/GameMode.h>
#include "ArmorScreen.h"
#include "../components/Button.h"

55
src/client/gui/screens/RenameMPLevelScreen.cpp
View File

@@ -1,55 +0,0 @@
#include "RenameMPLevelScreen.h"
#include "StartMenuScreen.h"
#include "DialogDefinitions.h"
#include "../Gui.h"
#include "../../Minecraft.h"
#include "../../../AppPlatform.h"
#include "../../../platform/log.h"
#include "../../../world/level/storage/LevelStorageSource.h"
static char ILLEGAL_FILE_CHARACTERS[] = {
'/', '\n', '\r', '\t', '\0', '\f', '`', '?', '*', '\\', '<', '>', '|', '\"', ':'
};
RenameMPLevelScreen::RenameMPLevelScreen( const std::string& levelId )
: _levelId(levelId)
{
}
void RenameMPLevelScreen::init() {
minecraft->platform()->createUserInput(DialogDefinitions::DIALOG_RENAME_MP_WORLD);
}
void RenameMPLevelScreen::render(int xm, int ym, float a)
{
renderBackground();
#ifdef WIN32
minecraft->getLevelSource()->renameLevel(_levelId, "Save?Level");
minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
#else
int status = minecraft->platform()->getUserInputStatus();
if (status > -1) {
if (status == 1) {
std::vector<std::string> v = minecraft->platform()->getUserInput();
if (!v.empty()) {
// Read the level name.
// 1) Trim name 2) Remove all bad chars -) We don't have to getUniqueLevelName, since renameLevel will do that
std::string levelId = v[0];
for (int i = 0; i < sizeof(ILLEGAL_FILE_CHARACTERS) / sizeof(char); ++i)
levelId = Util::stringReplace(levelId, std::string(1, ILLEGAL_FILE_CHARACTERS[i]), "");
if ((int)levelId.length() == 0) {
levelId = "saved_world";
}
minecraft->getLevelSource()->renameLevel(_levelId, levelId);
}
}
minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
}
#endif
}

18
src/client/gui/screens/RenameMPLevelScreen.h
View File

@@ -1,18 +0,0 @@
#ifndef NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__
#define NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__
#include "../Screen.h"
class RenameMPLevelScreen: public Screen
{
public:
RenameMPLevelScreen(const std::string& levelId);
virtual void init();
virtual void render(int xm, int ym, float a);
private:
std::string _levelId;
};
#endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__*/

3
src/client/gui/screens/ScreenChooser.cpp
View File

@@ -1,5 +1,6 @@
#include "ScreenChooser.h"
#include "StartMenuScreen.h"
#include "MinecraftClient.h"
#include "SelectWorldScreen.h"
#include "JoinGameScreen.h"
#include "PauseScreen.h"
@@ -58,6 +59,6 @@ Screen* ScreenChooser::createScreen( ScreenId id )
Screen* ScreenChooser::setScreen(ScreenId id)
{
Screen* screen = createScreen(id);
_mc->setScreen(screen);
_mc.setScreen(screen);
return screen;
}

8
src/client/gui/screens/ScreenChooser.h
View File

@@ -14,19 +14,17 @@ enum ScreenId {
};
class Screen;
class Minecraft;
class MinecraftClient;
class ScreenChooser
{
public:
ScreenChooser(Minecraft* mc)
: _mc(mc)
{}
ScreenChooser(MinecraftClient& mc) : _mc(mc) {}
Screen* createScreen(ScreenId id);
Screen* setScreen(ScreenId id);
private:
Minecraft* _mc;
MinecraftClient& _mc;
};
#endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__ScreenChooser_H__*/

3
src/client/gui/screens/SelectWorldScreen.cpp
View File

@@ -1,4 +1,5 @@
#include "SelectWorldScreen.h"
#include "MinecraftClient.h"
#include "StartMenuScreen.h"
#include "ProgressScreen.h"
#include "DialogDefinitions.h"
@@ -22,7 +23,7 @@ static float Max(float a, float b) {
//
// World Selection List
//
WorldSelectionList::WorldSelectionList( Minecraft* minecraft, int width, int height )
WorldSelectionList::WorldSelectionList( MinecraftClient& minecraft, int width, int height )
: _height(height),
hasPickedLevel(false),
currentTick(0),

4
src/client/gui/screens/SelectWorldScreen.h
View File

@@ -5,11 +5,11 @@
#include "../TweenData.h"
#include "../components/Button.h"
#include "../components/RolledSelectionListH.h"
#include "../../Minecraft.h"
#include "../../../world/level/storage/LevelStorageSource.h"
class SelectWorldScreen;
class MinecraftClient;
//
// Scrolling World selection list
@@ -17,7 +17,7 @@ class SelectWorldScreen;
class WorldSelectionList : public RolledSelectionListH
{
public:
WorldSelectionList(Minecraft* _minecraft, int _width, int _height);
WorldSelectionList(MinecraftClient& _minecraft, int _width, int _height);
virtual void tick();
void stepLeft();
void stepRight();

8
src/client/gui/screens/touch/TouchIngameBlockSelectionScreen.cpp
View File

@@ -3,7 +3,7 @@
#include "../../Screen.h"
#include "../../components/ImageButton.h"
#include "../../components/InventoryPane.h"
#include "../../../gamemode/GameMode.h"
#include <gamemode/GameMode.h>
#include "../../../renderer/TileRenderer.h"
#include "../../../player/LocalPlayer.h"
#include "../../../renderer/gles.h"
@@ -91,8 +91,7 @@ void IngameBlockSelectionScreen::init()
//for (int i = 0; i < inventory->getContainerSize(); ++i)
//LOGI("> %d - %s\n", i, inventory->getItem(i)? inventory->getItem(i)->getDescriptionId().c_str() : "<-->\n");
// Grid indices are 0..N-1 for main inventory only; slots 0..MAX_SELECTION_SIZE-1 are hotbar links.
InventorySize = inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
InventorySize = inventory->getContainerSize();
InventoryRows = 1 + (InventorySize-1) / InventoryColumns;
//
@@ -266,8 +265,7 @@ void IngameBlockSelectionScreen::buttonClicked(Button* button) {
bool IngameBlockSelectionScreen::isAllowed( int slot )
{
const int gridCount = minecraft->player->inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
if (slot < 0 || slot >= gridCount)
if (slot < 0 || slot >= minecraft->player->inventory->getContainerSize())
return false;
#ifdef DEMO_MODE

2
src/client/model/HumanoidModel.cpp
View File

@@ -1,5 +1,5 @@
#include "HumanoidModel.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../../util/Mth.h"
#include "../../world/entity/player/Player.h"
#include "../../world/entity/player/Inventory.h"

147
src/client/player/LocalPlayer.cpp
View File

@@ -1,6 +1,5 @@
#include "LocalPlayer.h"
#include "../Minecraft.h"
#include "../../ErrorCodes.h"
#include <Minecraft.h>
#include "../../world/entity/EntityEvent.h"
#include "../../world/entity/player/Player.h"
#include "../../world/inventory/BaseContainerMenu.h"
@@ -35,7 +34,7 @@
#include <errno.h>
#endif
#ifndef STANDALONE_SERVER
#include "../gui/Screen.h"
#include "../gui/screens/FurnaceScreen.h"
#include "../gui/screens/ChestScreen.h"
@@ -44,13 +43,13 @@
#include "../gui/screens/InBedScreen.h"
#include "../gui/screens/TextEditScreen.h"
#include "../particle/TakeAnimationParticle.h"
#endif
#include "../../network/packet/AnimatePacket.h"
#include "../../world/item/ArmorItem.h"
#include "../../network/packet/PlayerArmorEquipmentPacket.h"
#include <MinecraftClient.h>
namespace {
#ifndef STANDALONE_SERVER
static bool isBase64(unsigned char c) {
return (std::isalnum(c) || (c == '+') || (c == '/'));
@@ -233,7 +232,7 @@ static bool fileExists(const std::string& path) {
#endif
}
#ifndef STANDALONE_SERVER
static void* fetchSkinForPlayer(void* param) {
LocalPlayer* player = (LocalPlayer*)param;
@@ -345,33 +344,21 @@ static bool isJumpable(int tileId) {
} // anonymous namespace
LocalPlayer::LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative)
: Player(level, isCreative),
minecraft(minecraft),
input(NULL),
sentInventoryItemId(-1),
sentInventoryItemData(-1),
autoJumpEnabled(true),
armorTypeHash(0),
sprinting(false),
sprintDoubleTapTimer(0),
prevForwardHeld(false)
{
LocalPlayer::LocalPlayer(MinecraftClient& minecraft, Level* level, const std::string& username, int dimension, bool isCreative)
: Player(level, isCreative), minecraft(minecraft) {
this->dimension = dimension;
_init();
#ifndef STANDALONE_SERVER
if (minecraft->options.getStringValue(OPTIONS_USERNAME).size() != 0) {
if (minecraft.options().getStringValue(OPTIONS_USERNAME).size() != 0) {
textureName = "mob/char.png";
this->name = minecraft->options.getStringValue(OPTIONS_USERNAME);
this->name = minecraft.options().getStringValue(OPTIONS_USERNAME);
printf("test \n");
// Fetch user skin and cape from Mojang servers in the background (avoids blocking the main thread)
// TODO: Fix this memory leak
new CThread(fetchSkinForPlayer, this);
new CThread(fetchCapeForPlayer, this);
}
#endif
}
LocalPlayer::~LocalPlayer() {
@@ -381,8 +368,8 @@ LocalPlayer::~LocalPlayer() {
/*private*/
void LocalPlayer::calculateFlight(float xa, float ya, float za) {
float flySpeed = minecraft->options.getProgressValue(OPTIONS_FLY_SPEED);
float sensivity = minecraft->options.getProgressValue(OPTIONS_SENSITIVITY);
float flySpeed = minecraft.options().getProgressValue(OPTIONS_FLY_SPEED);
float sensivity = minecraft.options().getProgressValue(OPTIONS_SENSITIVITY);
xa = xa * flySpeed;
ya = 0;
@@ -434,12 +421,12 @@ void LocalPlayer::tick() {
stopUsingItem();
}
}
if (minecraft->isOnline())
if (minecraft.isOnline())
{
if (std::abs(x - sentX) > .1f || std::abs(y - sentY) > .01f || std::abs(z - sentZ) > .1f || std::abs(sentRotX - xRot) > 1 || std::abs(sentRotY - yRot) > 1)
{
MovePlayerPacket packet(entityId, x, y - heightOffset, z, xRot, yRot);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
sentX = x;
sentY = y;
sentZ = z;
@@ -457,7 +444,7 @@ void LocalPlayer::tick() {
sentInventoryItemId = newItemId;
sentInventoryItemData = newItemData;
PlayerEquipmentPacket packet(entityId, newItemId, newItemData);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
}
/*
@@ -472,15 +459,14 @@ void LocalPlayer::tick() {
*/
updateArmorTypeHash();
#ifndef STANDALONE_SERVER
if (!minecraft->screen && containerMenu) {
if (!minecraft.getScreen() && containerMenu) {
static bool hasPostedError = false;
if (!hasPostedError) {
minecraft->gui.postError( ErrorCodes::ContainerRefStillExistsAfterDestruction );
// @todo
// minecraft.gui().postError( ErrorCodes::ContainerRefStillExistsAfterDestruction );
hasPostedError = true;
}
}
#endif
//LOGI("biome: %s\n", level->getBiomeSource()->getBiome((int)x >> 4, (int)z >> 4)->name.c_str());
}
@@ -491,15 +477,14 @@ void LocalPlayer::aiStep() {
descendTriggerTime--;
bool wasJumping = input->jumping;
#ifndef STANDALONE_SERVER
bool screenCovering = minecraft->screen && !minecraft->screen->passEvents;
bool screenCovering = minecraft.getScreen() && !minecraft.getScreen()->passEvents;
if (!screenCovering)
input->tick(this);
// Sprint: detect W double-tap
{
bool forwardHeld = (input->ya > 0);
if (forwardHeld && !prevForwardHeld && minecraft->options.getBooleanValue(OPTIONS_ALLOW_SPRINT)) {
if (forwardHeld && !prevForwardHeld && minecraft.options().getBooleanValue(OPTIONS_ALLOW_SPRINT)) {
// leading edge of W press
if (sprintDoubleTapTimer > 0)
sprinting = true;
@@ -518,7 +503,7 @@ void LocalPlayer::aiStep() {
if (input->sneaking) {
if (ySlideOffset < 0.2f) ySlideOffset = 0.2f;
}
#endif
if (abilities.mayfly) {
// Check for flight toggle
if (!wasJumping && input->jumping) {
@@ -559,16 +544,16 @@ void LocalPlayer::aiStep() {
void LocalPlayer::closeContainer() {
if (level->isClientSide) {
ContainerClosePacket packet(containerMenu->containerId);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
super::closeContainer();
minecraft->setScreen(NULL);
minecraft.setScreen(NULL);
}
//@Override
void LocalPlayer::move(float xa, float ya, float za) {
//@note: why is this == minecraft->player needed?
if (this == minecraft->player && minecraft->options.getBooleanValue(OPTIONS_IS_FLYING)) {
//@note: why is this == minecraft.player needed?
if (this == minecraft.getPlayer() && minecraft.options().getBooleanValue(OPTIONS_IS_FLYING)) {
noPhysics = true;
float tmp = walkDist; // update
calculateFlight((float) xa, (float) ya, (float) za);
@@ -588,7 +573,7 @@ void LocalPlayer::move(float xa, float ya, float za) {
float newX = x, newZ = z;
if (autoJumpTime <= 0 && minecraft->options.getBooleanValue(OPTIONS_AUTOJUMP))
if (autoJumpTime <= 0 && minecraft.options().getBooleanValue(OPTIONS_AUTOJUMP))
{
// auto-jump when crossing the middle of a tile, and the tile in the front is blocked
bool jump = false;
@@ -617,12 +602,9 @@ void LocalPlayer::updateAi() {
this->jumping = input->jumping || autoJumpTime > 0;
}
void LocalPlayer::take( Entity* e, int orgCount )
{
#ifndef STANDALONE_SERVER
void LocalPlayer::take( Entity* e, int orgCount ) {
if (e->isItemEntity())
minecraft->particleEngine->add(new TakeAnimationParticle(minecraft->level, (ItemEntity*)e, this, -0.5f));
#endif
minecraft.getParticleEngine()->add(new TakeAnimationParticle(minecraft.level, (ItemEntity*)e, this, -0.5f));
}
void LocalPlayer::setKey( int eventKey, bool eventKeyState )
@@ -684,28 +666,25 @@ void LocalPlayer::hurtTo( int newHealth )
lastHealth = health;
invulnerableTime = invulnerableDuration;
minecraft->player->bypassArmor = true;
minecraft.getPlayer()->bypassArmor = true;
actuallyHurt(dmg);
minecraft->player->bypassArmor = false;
minecraft.getPlayer()->bypassArmor = false;
hurtTime = hurtDuration = 10;
}
}
void LocalPlayer::actuallyHurt( int dmg )
{
#ifndef STANDALONE_SERVER
if (minecraft->screen && minecraft->screen->closeOnPlayerHurt()) {
void LocalPlayer::actuallyHurt( int dmg ) {
if (minecraft.getScreen() && minecraft.getScreen()->closeOnPlayerHurt()) {
if (containerMenu) closeContainer();
else minecraft->setScreen(NULL);
else minecraft.setScreen(NULL);
}
#endif
super::actuallyHurt(dmg);
}
void LocalPlayer::respawn()
{
minecraft->respawnPlayer();
void LocalPlayer::respawn() {
minecraft.respawnPlayer();
}
void LocalPlayer::die(Entity* source)
@@ -714,7 +693,7 @@ void LocalPlayer::die(Entity* source)
// If we're the server, drop the inventory immediately
if (level->isClientSide) {
SendInventoryPacket packet(this, true);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
inventory->dropAll(level->isClientSide);
for (int i = 0; i < NUM_ARMOR; ++i) {
@@ -735,7 +714,7 @@ void LocalPlayer::swing() {
AnimatePacket packet(AnimatePacket::Swing, this);
packet.reliability = UNRELIABLE;
packet.priority = MEDIUM_PRIORITY;
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
}
@@ -758,31 +737,23 @@ void LocalPlayer::_init() {
}
void LocalPlayer::startCrafting(int x, int y, int z, int tableSize) {
#ifndef STANDALONE_SERVER
if (!minecraft->isCreativeMode())
minecraft->setScreen( new WorkbenchScreen(tableSize) );
#endif
if (!minecraft.isCreativeMode())
minecraft.setScreen( new WorkbenchScreen(tableSize) );
}
void LocalPlayer::startStonecutting(int x, int y, int z) {
#ifndef STANDALONE_SERVER
if (!minecraft->isCreativeMode())
minecraft->setScreen( new StonecutterScreen() );
#endif
if (!minecraft.isCreativeMode())
minecraft.setScreen( new StonecutterScreen() );
}
void LocalPlayer::openFurnace( FurnaceTileEntity* e ) {
#ifndef STANDALONE_SERVER
if (!minecraft->isCreativeMode())
minecraft->setScreen( new FurnaceScreen(this, e) );
#endif
if (!minecraft.isCreativeMode())
minecraft.setScreen( new FurnaceScreen(this, e) );
}
void LocalPlayer::openContainer( ChestTileEntity* container ) {
#ifndef STANDALONE_SERVER
if (!minecraft->isCreativeMode())
minecraft->setScreen( new ChestScreen(this, container) );
#endif
if (!minecraft.isCreativeMode())
minecraft.setScreen( new ChestScreen(this, container) );
}
void LocalPlayer::drop( ItemInstance* item, bool randomly )
@@ -792,7 +763,7 @@ void LocalPlayer::drop( ItemInstance* item, bool randomly )
if (level->isClientSide) {
DropItemPacket packet(entityId, *item);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
// delete the ItemEntity here, since we don't add it to level
delete item;
} else {
@@ -806,7 +777,7 @@ void LocalPlayer::causeFallDamage( float distance )
if (dmg > 0) {
if (level->isClientSide) {
SetHealthPacket packet(SetHealthPacket::HEALTH_MODIFY_OFFSET + dmg);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
}
super::causeFallDamage(distance);
@@ -814,35 +785,33 @@ void LocalPlayer::causeFallDamage( float distance )
}
void LocalPlayer::displayClientMessage( const std::string& messageId ) {
#ifndef STANDALONE_SERVER
minecraft->gui.displayClientMessage(messageId);
#endif
minecraft.gui().displayClientMessage(messageId);
}
int LocalPlayer::startSleepInBed( int x, int y, int z ) {
int startSleepInBedReturnValue = super::startSleepInBed(x, y, z);
#ifndef STANDALONE_SERVER
if(startSleepInBedReturnValue == BedSleepingResult::OK)
minecraft->setScreen(new InBedScreen());
#endif
minecraft.setScreen(new InBedScreen());
return startSleepInBedReturnValue;
}
void LocalPlayer::stopSleepInBed( bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint ) {
if(level->isClientSide) {
PlayerActionPacket packet(PlayerActionPacket::STOP_SLEEPING, 0, 0, 0, 0, entityId);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
#ifndef STANDALONE_SERVER
minecraft->setScreen(NULL);
#endif
minecraft.setScreen(NULL);
super::stopSleepInBed(forcefulWakeUp, updateLevelList, saveRespawnPoint);
}
void LocalPlayer::openTextEdit( TileEntity* tileEntity ) {
#if !defined(STANDALONE_SERVER) && !defined(RPI)
#if !defined(RPI)
if(tileEntity->type == TileEntityType::Sign)
minecraft->setScreen(new TextEditScreen((SignTileEntity*) tileEntity));
minecraft.setScreen(new TextEditScreen((SignTileEntity*) tileEntity));
#endif
}
@@ -850,7 +819,7 @@ void LocalPlayer::updateArmorTypeHash() {
int hash = getArmorTypeHash();
if (hash != armorTypeHash) {
PlayerArmorEquipmentPacket p(this);
minecraft->raknetInstance->send(p);
minecraft.raknetInstance->send(p);
armorTypeHash = hash;
}
}

22
src/client/player/LocalPlayer.h
View File

@@ -7,7 +7,7 @@
#include "../../util/SmoothFloat.h"
#include "../../world/entity/player/Player.h"
class Minecraft;
class MinecraftClient;
class Stat;
class CompoundTag;
@@ -15,7 +15,7 @@ class LocalPlayer: public Player
{
typedef Player super;
public:
LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative);
LocalPlayer(MinecraftClient& minecraft, Level* level, const std::string& username, int dimension, bool isCreative);
~LocalPlayer();
void _init();
@@ -74,10 +74,10 @@ private:
bool isSolidTile(int x, int y, int z);
void updateArmorTypeHash();
public:
IMoveInput* input;
bool autoJumpEnabled;
IMoveInput* input = nullptr;
bool autoJumpEnabled = true;
protected:
Minecraft* minecraft;
MinecraftClient& minecraft;
int jumpTriggerTime;
int ascendTriggerTime;
int descendTriggerTime;
@@ -94,15 +94,15 @@ private:
int autoJumpTime;
int sentInventoryItemId;
int sentInventoryItemData;
int sentInventoryItemId = -1;
int sentInventoryItemData = -1;
int armorTypeHash;
int armorTypeHash = 0;
// sprinting
bool sprinting;
int sprintDoubleTapTimer;
bool prevForwardHeld;
bool sprinting = false;
int sprintDoubleTapTimer = 0;
bool prevForwardHeld = false;
public:
void setSprinting(bool sprint) { sprinting = sprint; }
};

2
src/client/renderer/Color4.h
View File

@@ -44,7 +44,7 @@ private:
range(b);
range(a);
}
__inline void range(GLfloat& v) {
inline void range(GLfloat& v) {
if (v < 0) v = 0;
if (v > 1) v = 1;
}

2
src/client/renderer/GameRenderer.cpp
View File

@@ -9,7 +9,7 @@
#include "culling/AllowAllCuller.h"
#include "culling/FrustumCuller.h"
#include "entity/EntityRenderDispatcher.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../gamemode/GameMode.h"
#include "../particle/ParticleEngine.h"
#include "../player/LocalPlayer.h"

2
src/client/renderer/ItemInHandRenderer.cpp
View File

@@ -5,7 +5,7 @@
#include "entity/EntityRenderDispatcher.h"
#include "entity/EntityRenderer.h"
#include "entity/MobRenderer.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../player/LocalPlayer.h"
#include "../../world/entity/player/Player.h"
#include "../../world/item/Item.h"

2
src/client/renderer/LevelRenderer.cpp
View File

@@ -4,7 +4,7 @@
#include "DistanceChunkSorter.h"
#include "Chunk.h"
#include "TileRenderer.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../../util/Mth.h"
#include "../../world/entity/player/Player.h"
#include "../../world/level/tile/LevelEvent.h"

6
src/client/renderer/LevelRenderer.h
View File

@@ -9,7 +9,7 @@
#include "gles.h"
#include <vector>
class Minecraft;
class MinecraftClient;
class Textures;
class Culler;
class Chunk;
@@ -33,7 +33,7 @@ public:
float zOld;
float destroyProgress;
LevelRenderer(Minecraft* mc);
LevelRenderer(MinecraftClient& mc);
~LevelRenderer();
void setLevel(Level* level);
@@ -77,7 +77,7 @@ private:
void resortChunks(int xc, int yc, int zc);
void deleteChunks();
//void checkQueryResults(int from, int to);
__inline int getLinearCoord(int x, int y, int z) {
inline int getLinearCoord(int x, int y, int z) {
return (z * yChunks + y) * xChunks + x;
}
int noEntityRenderFrames;

2
src/client/renderer/RenderList.h
View File

@@ -18,7 +18,7 @@ public:
void add(int list);
void addR(const RenderChunk& chunk);
__inline void next() { ++listIndex; }
inline void next() { ++listIndex; }
void render();
void renderChunks();

8
src/client/renderer/Tesselator.h
View File

@@ -72,18 +72,18 @@ public:
int getColor();
__inline void beginOverride() {
inline void beginOverride() {
begin();
voidBeginAndEndCalls(true);
}
__inline void endOverrideAndDraw() {
inline void endOverrideAndDraw() {
voidBeginAndEndCalls(false);
draw();
}
__inline bool isOverridden() {
inline bool isOverridden() {
return _voidBeginEnd;
}
__inline RenderChunk endOverride(int bufferId) {
inline RenderChunk endOverride(int bufferId) {
voidBeginAndEndCalls(false);
return end(true, bufferId);
}

42
src/client/renderer/Textures.cpp
View File

@@ -4,34 +4,20 @@
#include "ptexture/DynamicTexture.h"
#include "../Options.h"
#include "../../platform/time.h"
#include "../../AppPlatform.h"
#include "../../util/StringUtils.h"
/*static*/ int Textures::textureChanges = 0;
/*static*/ bool Textures::MIPMAP = false;
/*static*/ const TextureId Textures::InvalidId = -1;
Textures::Textures( Options* options_, AppPlatform* platform_ )
: clamp(false),
blur(false),
options(options_),
platform(platform_),
lastBoundTexture(Textures::InvalidId)
{
}
Textures::~Textures()
{
Textures::~Textures() {
clear();
for (unsigned int i = 0; i < dynamicTextures.size(); ++i)
delete dynamicTextures[i];
}
void Textures::clear()
{
void Textures::clear() {
for (TextureMap::iterator it = idMap.begin(); it != idMap.end(); ++it) {
if (it->second != Textures::InvalidId)
if (it->second != TEXTURES_INVALID_ID)
glDeleteTextures(1, &it->second);
}
for (TextureImageMap::iterator it = loadedImages.begin(); it != loadedImages.end(); ++it) {
@@ -41,7 +27,7 @@ void Textures::clear()
idMap.clear();
loadedImages.clear();
lastBoundTexture = Textures::InvalidId;
lastBoundTexture = TEXTURES_INVALID_ID;
}
TextureId Textures::loadAndBindTexture( const std::string& resourceName )
@@ -51,7 +37,7 @@ TextureId Textures::loadAndBindTexture( const std::string& resourceName )
//t.start();
TextureId id = loadTexture(resourceName);
//t.stop();
if (id != Textures::InvalidId)
if (id != TEXTURES_INVALID_ID)
bind(id);
//t.printEvery(1000);
@@ -59,25 +45,24 @@ TextureId Textures::loadAndBindTexture( const std::string& resourceName )
return id;
}
TextureId Textures::loadTexture( const std::string& resourceName, bool inTextureFolder /* = true */ )
{
TextureId Textures::loadTexture(const std::string& resourceName, bool inTextureFolder) {
TextureMap::iterator it = idMap.find(resourceName);
if (it != idMap.end())
return it->second;
bool isUrl = Util::startsWith(resourceName, "http://") || Util::startsWith(resourceName, "https://");
TextureData texdata = platform->loadTexture(resourceName, isUrl ? false : inTextureFolder);
TextureData texdata = m_platform.loadTexture(resourceName, isUrl ? false : inTextureFolder);
if (texdata.data)
return assignTexture(resourceName, texdata);
else if (texdata.identifier != InvalidId) {
else if (texdata.identifier != TEXTURES_INVALID_ID) {
//LOGI("Adding id: %d for %s\n", texdata.identifier, resourceName.c_str());
idMap.insert(std::make_pair(resourceName, texdata.identifier));
}
else {
idMap.insert(std::make_pair(resourceName, Textures::InvalidId));
idMap.insert(std::make_pair(resourceName, TEXTURES_INVALID_ID));
//loadedImages.insert(std::make_pair(InvalidId, texdata));
}
return Textures::InvalidId;
return TEXTURES_INVALID_ID;
}
TextureId Textures::assignTexture( const std::string& resourceName, const TextureData& img )
@@ -87,13 +72,14 @@ TextureId Textures::assignTexture( const std::string& resourceName, const Textur
bind(id);
if (MIPMAP) {
#ifdef TEXTURES_MIPMAP
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
#else
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
#endif
if (blur) {
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

27
src/client/renderer/Textures.h
View File

@@ -6,9 +6,13 @@
#include <string>
#include <map>
#include <utility>
#include <IPlatform.h>
#include "gles.h"
#include "TextureData.h"
#define TEXTURES_INVALID_ID -1
#define TEXTURES_MIPMAP 0
class DynamicTexture;
class Options;
class AppPlatform;
@@ -24,20 +28,21 @@ typedef std::map<TextureId, TextureData> TextureImageMap;
class Textures
{
public:
Textures(Options* options_, AppPlatform* platform_);
Textures(Options& options, IPlatform& platform) : m_options(options), m_platform(platform) {}
~Textures();
void addDynamicTexture(DynamicTexture* dynamicTexture);
__inline void bind(TextureId id) {
if (id != Textures::InvalidId && lastBoundTexture != id) {
inline void bind(TextureId id) {
if (id != TEXTURES_INVALID_ID && lastBoundTexture != id) {
glBindTexture2(GL_TEXTURE_2D, id);
lastBoundTexture = id;
++textureChanges;
} else if (id == Textures::InvalidId){
} else if (id == TEXTURES_INVALID_ID){
LOGI("invalidId!\n");
}
}
TextureId loadTexture(const std::string& resourceName, bool inTextureFolder = true);
TextureId loadAndBindTexture(const std::string& resourceName);
@@ -49,28 +54,26 @@ public:
void clear();
void reloadAll();
__inline static bool isTextureIdValid(TextureId t) { return t != Textures::InvalidId; }
inline static bool isTextureIdValid(TextureId t) { return t != TEXTURES_INVALID_ID; }
private:
int smoothBlend(int c0, int c1);
int crispBlend(int c0, int c1);
public:
static bool MIPMAP;
static int textureChanges;
static const TextureId InvalidId;
private:
TextureMap idMap;
TextureImageMap loadedImages;
Options* options;
AppPlatform* platform;
Options& m_options;
IPlatform& m_platform;
bool clamp;
bool blur;
bool clamp = false;
bool blur = false;
int lastBoundTexture;
int lastBoundTexture = TEXTURES_INVALID_ID;
std::vector<DynamicTexture*> dynamicTextures;
};

2
src/client/renderer/TileRenderer.cpp
View File

@@ -1,6 +1,6 @@
#include "TileRenderer.h"
#include "Chunk.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "Tesselator.h"
#include "../../world/level/LevelSource.h"

2
src/client/sound/SoundEngine.cpp
View File

@@ -1,6 +1,6 @@
#include "SoundEngine.h"
#include "../Options.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../../world/entity/Mob.h"

2
src/client/sound/SoundEngine.mm
View File

@@ -1,6 +1,6 @@
#include "SoundEngine.h"
#include "../Options.h"
#include "../Minecraft.h"
#include <Minecraft.h>
#include "../../world/entity/Mob.h"
/*

59
src/gamemode/CreativeMode.cpp Executable file
View File

@@ -0,0 +1,59 @@
#include "CreativeMode.h"
#include <Minecraft.h>
#include <world/level/Level.h>
#include <world/entity/player/Abilities.h>
static const int DestructionTickDelay = 5;
CreativeMode::CreativeMode(Minecraft& minecraft)
: super(minecraft)
{
}
void CreativeMode::startDestroyBlock(Player* player, int x, int y, int z, int face) {
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
return;
creativeDestroyBlock(player, x, y, z, face);
destroyDelay = DestructionTickDelay;
}
void CreativeMode::creativeDestroyBlock(Player* player, int x, int y, int z, int face) {
minecraft.level->extinguishFire(x, y, z, face);
destroyBlock(player, x, y, z, face);
}
void CreativeMode::continueDestroyBlock(Player* player, int x, int y, int z, int face) {
destroyDelay--;
if (destroyDelay <= 0) {
destroyDelay = DestructionTickDelay;
creativeDestroyBlock(player, x, y, z, face);
}
}
void CreativeMode::stopDestroyBlock(Player* player) {
destroyDelay = 0;
}
void CreativeMode::initAbilities( Abilities& abilities ) {
abilities.mayfly = true;
abilities.instabuild = true;
abilities.invulnerable = true;
}
bool CreativeMode::isCreativeType() {
return true;
}
void CreativeMode::releaseUsingItem( Player* player ) {
if(player->getCarriedItem() != NULL) {
int oldItemId = player->getCarriedItem()->id;
int oldAux = player->getAuxData();
super::releaseUsingItem(player);
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == oldItemId) {
player->getCarriedItem()->setAuxValue(oldAux);
}
} else {
super::releaseUsingItem(player);
}
}

11
src/client/gamemode/CreativeMode.h → src/gamemode/CreativeMode.h
View File

@@ -9,18 +9,19 @@ class CreativeMode: public GameMode
{
typedef GameMode super;
public:
CreativeMode(Minecraft* minecraft);
CreativeMode(Minecraft& minecraft);
void startDestroyBlock(int x, int y, int z, int face);
void continueDestroyBlock(int x, int y, int z, int face);
void stopDestroyBlock();
void startDestroyBlock(Player* player, int x, int y, int z, int face);
void continueDestroyBlock(Player* player, int x, int y, int z, int face);
void stopDestroyBlock(Player* player);
bool isCreativeType();
void initAbilities(Abilities& abilities);
void releaseUsingItem(Player* player);
private:
void creativeDestroyBlock(int x, int y, int z, int face);
void creativeDestroyBlock(Player* player, int x, int y, int z, int face);
};
#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__*/

111
src/gamemode/CreatorMode.cpp Executable file
View File

@@ -0,0 +1,111 @@
#include "CreatorMode.h"
#include "world/entity/player/Player.h"
#include "world/level/Level.h"
#include <Minecraft.h>
#include <world/entity/player/Abilities.h>
static const int DestructionTickDelay = 5;
class Creator: public ICreator {
//virtual void getEvents();
public:
Creator(/*int eventLifeTime*/)
: _tileEvents(32),
_tickId(0)
{
}
void setTick(int tick) {
_tickId = tick;
}
EventList<TileEvent>& getTileEvents() { return _tileEvents; }
void addevent_blockUse(int entityId, int x, int y, int z, int face) {
TileEvent t = {
entityId,
x,y,z,
face
};
_tileEvents.add(t, _tickId);
}
private:
EventList<TileEvent> _tileEvents;
int _tickId;
};
CreatorMode::CreatorMode(Minecraft& minecraft)
: super(minecraft)
{
_creator = new Creator();
}
CreatorMode::~CreatorMode() {
delete _creator;
}
void CreatorMode::startDestroyBlock(Player* player, int x, int y, int z, int face) {
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
return;
CreatorDestroyBlock(player, x, y, z, face);
destroyDelay = DestructionTickDelay;
}
void CreatorMode::CreatorDestroyBlock(Player* player, int x, int y, int z, int face) {
minecraft.level->extinguishFire(x, y, z, face);
destroyBlock(player, x, y, z, face);
}
void CreatorMode::continueDestroyBlock(Player* player, int x, int y, int z, int face) {
destroyDelay--;
if (destroyDelay <= 0) {
destroyDelay = DestructionTickDelay;
CreatorDestroyBlock(player, x, y, z, face);
}
}
bool CreatorMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit ) {
if (item && item->id == ((Item*)Item::sword_iron)->id)
_creator->addevent_blockUse(player->entityId, x, y, z, face);
return super::useItemOn(player, level, item, x, y, z, face, hit);
}
void CreatorMode::stopDestroyBlock(Player* player) {
destroyDelay = 0;
}
void CreatorMode::initAbilities( Abilities& abilities ) {
abilities.mayfly = true;
abilities.instabuild = true;
abilities.invulnerable = true;
}
bool CreatorMode::isCreativeType() {
return true;
}
void CreatorMode::releaseUsingItem( Player* player ) {
if(player->getCarriedItem() != NULL) {
int oldItemId = player->getCarriedItem()->id;
int oldAux = player->getAuxData();
super::releaseUsingItem(player);
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == oldItemId) {
player->getCarriedItem()->setAuxValue(oldAux);
}
} else {
super::releaseUsingItem(player);
}
}
ICreator* CreatorMode::getCreator() {
return _creator;
}
void CreatorMode::tick() {
_creator->setTick(minecraft.level->getTime());
super::tick();
}

13
src/client/gamemode/CreatorMode.h → src/gamemode/CreatorMode.h
View File

@@ -4,7 +4,7 @@
//package net.minecraft.client.gamemode;
#include "GameMode.h"
#include "../../world/PosTranslator.h"
#include <world/PosTranslator.h>
class ICreator {
public:
@@ -102,12 +102,12 @@ class CreatorMode: public GameMode
{
typedef GameMode super;
public:
CreatorMode(Minecraft* minecraft);
CreatorMode(Minecraft& minecraft);
~CreatorMode();
void startDestroyBlock(int x, int y, int z, int face);
void continueDestroyBlock(int x, int y, int z, int face);
void stopDestroyBlock();
void startDestroyBlock(Player* player, int x, int y, int z, int face);
void continueDestroyBlock(Player* player, int x, int y, int z, int face);
void stopDestroyBlock(Player* player);
bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
@@ -118,8 +118,9 @@ public:
void initAbilities(Abilities& abilities);
void releaseUsingItem(Player* player);
private:
void CreatorDestroyBlock(int x, int y, int z, int face);
void CreatorDestroyBlock(Player* player, int x, int y, int z, int face);
Creator* _creator;
};

93
src/client/gamemode/GameMode.cpp → src/gamemode/GameMode.cpp
View File

@@ -1,35 +1,15 @@
#include "GameMode.h"
#include "../Minecraft.h"
#include "../../network/packet/UseItemPacket.h"
#include "../../network/packet/PlayerActionPacket.h"
#include "../../world/level/Level.h"
#include "../../world/item/ItemInstance.h"
#include "../player/LocalPlayer.h"
#include "client/Options.h"
#ifndef STANDALONE_SERVER
#include "../sound/SoundEngine.h"
#include "../particle/ParticleEngine.h"
#endif
#include "../../network/RakNetInstance.h"
#include "../../network/packet/RemoveBlockPacket.h"
#ifndef STANDALONE_SERVER
#include "../renderer/LevelRenderer.h"
#endif
#include "../../world/level/material/Material.h"
#include <Minecraft.h>
#include <network/packet/UseItemPacket.h>
#include <network/packet/PlayerActionPacket.h>
#include <world/level/Level.h>
#include <world/item/ItemInstance.h>
#include <client/player/LocalPlayer.h>
#include <client/Options.h>
#include <network/RakNetInstance.h>
#include <network/packet/RemoveBlockPacket.h>
#include <world/level/material/Material.h>
GameMode::GameMode( Minecraft* minecraft)
: minecraft(minecraft),
destroyProgress(0),
oDestroyProgress(0),
destroyTicks(0),
destroyDelay(0)
{
}
/*virtual*/
Player* GameMode::createPlayer(Level* level) {
return new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreativeType());
}
/*virtual*/
void GameMode::interact(Player* player, Entity* entity) {
@@ -38,23 +18,24 @@ void GameMode::interact(Player* player, Entity* entity) {
/*virtual*/
void GameMode::attack(Player* player, Entity* entity) {
if (minecraft->level->adventureSettings.noPvP && entity->isPlayer())
if (minecraft.level->adventureSettings.noPvP && entity->isPlayer())
return;
if (minecraft->level->adventureSettings.noPvM && entity->isMob())
if (minecraft.level->adventureSettings.noPvM && entity->isMob())
return;
player->attack(entity);
}
/* virtual */
void GameMode::startDestroyBlock( int x, int y, int z, int face ) {
if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
void GameMode::startDestroyBlock(Player* player, int x, int y, int z, int face ) {
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
return;
destroyBlock(x, y, z, face);
destroyBlock(player, x, y, z, face);
}
/*virtual*/
bool GameMode::destroyBlock(int x, int y, int z, int face) {
Level* level = minecraft->level;
bool GameMode::destroyBlock(Player* player, int x, int y, int z, int face) {
Level* level = minecraft.level;
Tile* oldTile = Tile::tiles[level->getTile(x, y, z)];
if (!oldTile)
return false;
@@ -65,22 +46,12 @@ bool GameMode::destroyBlock(int x, int y, int z, int face) {
return false;
}
}
#ifndef STANDALONE_SERVER
minecraft->particleEngine->destroy(x, y, z);
#endif
int data = level->getData(x, y, z);
bool changed = level->setTile(x, y, z, 0);
if (changed) {
#ifndef STANDALONE_SERVER
minecraft->soundEngine->play(oldTile->soundType->getBreakSound(), x + 0.5f, y + 0.5f, z + 0.5f, (oldTile->soundType->getVolume() + 1) / 2, oldTile->soundType->getPitch() * 0.8f);
#endif
oldTile->destroy(level, x, y, z, data);
if (minecraft->options.getBooleanValue(OPTIONS_DESTROY_VIBRATION)) minecraft->platform()->vibrate(24);
if (minecraft->isOnline()) {
RemoveBlockPacket packet(minecraft->player, x, y, z);
minecraft->raknetInstance->send(packet);
}
minecraft.onBlockDestroyed(player, x, y, z, face);
}
return changed;
}
@@ -89,10 +60,10 @@ bool GameMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x
float clickX = hit.x - x;
float clickY = hit.y - y;
float clickZ = hit.z - z;
if (level->isClientSide) {
item = player->inventory->getSelected();
item = player->inventory->getSelected();
if(level->isClientSide) {
UseItemPacket packet(x, y, z, face, item, player->entityId, clickX, clickY, clickZ);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
int t = level->getTile(x, y, z);
if (t == Tile::invisible_bedrock->id) return false;
@@ -118,7 +89,7 @@ bool GameMode::useItem( Player* player, Level* level, ItemInstance* item ) {
ItemInstance* itemInstance = item->use(level, player);
if(level->isClientSide) {
UseItemPacket packet(item, player->entityId, player->aimDirection);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
if (itemInstance != item || (itemInstance != NULL && itemInstance->count != oldCount)) {
//player.inventory.items[player.inventory.selected] = itemInstance;
@@ -149,9 +120,9 @@ void GameMode::initPlayer( Player* player ) {
}
void GameMode::releaseUsingItem(Player* player){
if (minecraft->level->isClientSide && player->isUsingItem()) {
if(minecraft.level->isClientSide) {
PlayerActionPacket packet(PlayerActionPacket::RELEASE_USE_ITEM, 0, 0, 0, 0, player->entityId);
minecraft->raknetInstance->send(packet);
minecraft.raknetInstance->send(packet);
}
player->releaseUsingItem();
}
@@ -160,15 +131,3 @@ void GameMode::tick() {
oDestroyProgress = destroyProgress;
}
void GameMode::render( float a ) {
#ifndef STANDALONE_SERVER
if (destroyProgress <= 0) {
minecraft->gui.progress = 0;
minecraft->levelRenderer->destroyProgress = 0;
} else {
float dp = oDestroyProgress + (destroyProgress - oDestroyProgress) * a;
minecraft->gui.progress = dp;
minecraft->levelRenderer->destroyProgress = dp;
}
#endif
}

28
src/client/gamemode/GameMode.h → src/gamemode/GameMode.h
View File

@@ -3,7 +3,7 @@
//package net.minecraft.client.gamemode;
#include "../../world/level/tile/Tile.h"
#include <world/level/tile/Tile.h>
class ItemInstance;
class Minecraft;
@@ -11,23 +11,22 @@ class Level;
class Player;
class Abilities;
class GameMode
{
class GameMode {
protected:
Minecraft* minecraft;
Minecraft& minecraft;
public:
GameMode(Minecraft* minecraft);
GameMode(Minecraft& minecraft) : minecraft(minecraft) {}
virtual ~GameMode() {}
virtual void initLevel(Level* level) {}
virtual void startDestroyBlock(int x, int y, int z, int face);
virtual bool destroyBlock(int x, int y, int z, int face);
virtual void continueDestroyBlock(int x, int y, int z, int face) = 0;
virtual void stopDestroyBlock() {}
virtual void startDestroyBlock(Player* player, int x, int y, int z, int face);
virtual bool destroyBlock(Player* player, int x, int y, int z, int face);
virtual void continueDestroyBlock(Player* player, int x, int y, int z, int face) = 0;
virtual void stopDestroyBlock(Player* player) {}
virtual void tick();
virtual void render(float a);
virtual float getPickRange();
/* void postLevelGen(LevelGen levelGen, Level level) {} */
@@ -35,7 +34,6 @@ public:
virtual bool useItem(Player* player, Level* level, ItemInstance* item);
virtual bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
virtual Player* createPlayer(Level* level);
virtual void initPlayer(Player* player);
virtual void adjustPlayer(Player* player) {}
virtual bool canHurtPlayer() { return false; }
@@ -53,11 +51,11 @@ public:
virtual void releaseUsingItem(Player* player);
float oDestroyProgress;
float destroyProgress;
float oDestroyProgress = 0;
float destroyProgress = 0;
protected:
int destroyTicks;
int destroyDelay;
int destroyTicks = 0;
int destroyDelay = 0;
};
#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__GameMode_H__*/

93
src/gamemode/SurvivalMode.cpp Executable file
View File

@@ -0,0 +1,93 @@
#include "SurvivalMode.h"
#include <Minecraft.h>
#include <world/level/Level.h>
#include <world/entity/player/Abilities.h>
SurvivalMode::SurvivalMode( Minecraft& minecraft )
: super(minecraft),
xDestroyBlock(-1),
yDestroyBlock(-1),
zDestroyBlock(-1)
{
}
void SurvivalMode::continueDestroyBlock(Player* player, int x, int y, int z, int face ) {
if (destroyDelay > 0) {
destroyDelay--;
return;
}
if (x == xDestroyBlock && y == yDestroyBlock && z == zDestroyBlock) {
int t = minecraft.level->getTile(x, y, z);
if (t == 0) return;
Tile* tile = Tile::tiles[t];
destroyProgress += tile->getDestroyProgress(player);
if ((++destroyTicks & 3) == 1) {
#ifndef STANDALONE_SERVER
if (tile != NULL) {
minecraft->soundEngine->play(tile->soundType->getStepSound(), x + 0.5f, y + 0.5f, z + 0.5f, (tile->soundType->getVolume() + 1) / 8, tile->soundType->getPitch() * 0.5f);
}
#endif
}
if (destroyProgress >= 1) {
destroyBlock(player, x, y, z, face);
destroyProgress = 0;
oDestroyProgress = 0;
destroyTicks = 0;
destroyDelay = 5;
}
} else {
destroyProgress = 0;
oDestroyProgress = 0;
destroyTicks = 0;
xDestroyBlock = x;
yDestroyBlock = y;
zDestroyBlock = z;
}
}
bool SurvivalMode::destroyBlock(Player* player, int x, int y, int z, int face ) {
int t = minecraft.level->getTile(x, y, z);
int data = minecraft.level->getData(x, y, z);
bool changed = GameMode::destroyBlock(player, x, y, z, face);
bool couldDestroy = player->canDestroy(Tile::tiles[t]);
ItemInstance* item = player->inventory->getSelected();
if (item != NULL) {
item->mineBlock(t, x, y, z);
if (item->count == 0) {
//item->snap(minecraft->player);
player->inventory->clearSlot(player->inventory->selected);
}
}
if (changed && couldDestroy) {
ItemInstance instance(t, 1, data);
Tile::tiles[t]->playerDestroy(minecraft.level, player, x, y, z, data);
}
return changed;
}
void SurvivalMode::stopDestroyBlock(Player* player) {
destroyProgress = 0;
destroyDelay = 0;
}
void SurvivalMode::initAbilities( Abilities& abilities ) {
abilities.flying = false;
abilities.mayfly = false;
abilities.instabuild = false;
abilities.invulnerable = false;
}
void SurvivalMode::startDestroyBlock(Player* player, int x, int y, int z, int face ) {
if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
return;
int t = minecraft.level->getTile(x, y, z);
if (t > 0 && destroyProgress == 0) Tile::tiles[t]->attack(minecraft.level, x, y, z, player);
if (t > 0 && Tile::tiles[t]->getDestroyProgress(player) >= 1)
destroyBlock(player, x, y, z, face);
}

10
src/client/gamemode/SurvivalMode.h → src/gamemode/SurvivalMode.h
View File

@@ -10,12 +10,12 @@ class SurvivalMode: public GameMode
{
typedef GameMode super;
public:
SurvivalMode(Minecraft* minecraft);
SurvivalMode(Minecraft& minecraft);
bool destroyBlock(int x, int y, int z, int face);
void startDestroyBlock(int x, int y, int z, int face);
void continueDestroyBlock(int x, int y, int z, int face);
void stopDestroyBlock();
bool destroyBlock(Player* player, int x, int y, int z, int face);
void startDestroyBlock(Player* player, int x, int y, int z, int face);
void continueDestroyBlock(Player* player, int x, int y, int z, int face);
void stopDestroyBlock(Player* player);
bool canHurtPlayer() { return true; }

23
src/locale/I18n.cpp
View File

@@ -1,6 +1,6 @@
#include "I18n.h"
#include <sstream>
#include "../AppPlatform.h"
#include <IPlatform.h>
#include "../util/StringUtils.h"
#include "../world/level/tile/Tile.h"
#include "../world/item/ItemInstance.h"
@@ -8,8 +8,7 @@
I18n::Map I18n::_strings;
void I18n::loadLanguage( AppPlatform* platform, const std::string& languageCode )
{
void I18n::loadLanguage(IPlatform& platform, const std::string& languageCode ) {
_strings.clear();
fillTranslations(platform, "lang/en_US.lang", true);
@@ -26,8 +25,7 @@ bool I18n::get( const std::string& id, std::string& out ) {
return false;
}
std::string I18n::get( const std::string& id )
{
std::string I18n::get( const std::string& id ) {
Map::const_iterator cit = _strings.find(id);
if (cit != _strings.end())
return cit->second;
@@ -35,13 +33,11 @@ std::string I18n::get( const std::string& id )
return id + '<';//lang.getElement(id);
}
void I18n::fillTranslations( AppPlatform* platform, const std::string& filename, bool overwrite )
{
BinaryBlob blob = platform->readAssetFile(filename);
if (!blob.data || blob.size <= 0)
return;
void I18n::fillTranslations(IPlatform& platform, const std::string& filename, bool overwrite ) {
auto blob = platform.readAssetFile(filename);
if (blob.empty()) return;
std::string data((const char*)blob.data, blob.size);
std::string data(blob.begin(), blob.end());
std::stringstream fin(data, std::ios_base::in);
std::string line;
@@ -58,12 +54,9 @@ void I18n::fillTranslations( AppPlatform* platform, const std::string& filename,
std::string value = Util::stringTrim(line.substr(spos + 1));
_strings.insert( std::make_pair(key, value ) );
}
delete[] blob.data;
}
std::string I18n::getDescriptionString( const ItemInstance& item )
{
std::string I18n::getDescriptionString( const ItemInstance& item ) {
// Convert to lower. Normally std::transform would be used, but tolower might be
// implemented with a macro in certain C-implementations -> messing stuff up
const std::string desc = item.getDescriptionId();

8
src/locale/I18n.h
View File

@@ -3,17 +3,17 @@
//package net.minecraft.locale;
#include "IPlatform.h"
#include <map>
#include <string>
class AppPlatform;
class ItemInstance;
class I18n
{
class I18n {
typedef std::map<std::string, std::string> Map;
public:
static void loadLanguage(AppPlatform* platform, const std::string& languageCode);
static void loadLanguage(IPlatform& platform, const std::string& languageCode);
static bool get(const std::string& id, std::string& out);
static std::string get(const std::string& id);
@@ -24,7 +24,7 @@ public:
static std::string getDescriptionString( const ItemInstance& item );
private:
static void fillTranslations(AppPlatform* platform, const std::string& filename, bool overwrite);
static void fillTranslations(IPlatform& platform, const std::string& filename, bool overwrite);
static Map _strings;
};

49
src/main.cpp
View File

@@ -1,46 +1,9 @@
/**
Entry point for cross compilation.
#include "MinecraftClient.h"
This is ugly, yes. But it will change in the "half near" future
to a more correct system of solving the cross-platform entry
point "problem" */
#define _SECURE_SCL 0
// #ifdef WIN32
// #include "vld.h"
// #endif
#include "platform/log.h"
#ifdef WIN32
#endif
#ifdef ANDROID
#endif
#include "NinecraftApp.h"
#define MAIN_CLASS NinecraftApp
// #ifdef PLATFORM_WINDOWS
// #include "main_win32.h"
// #endif
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
#include "main_glfw.h"
#endif
#ifdef PLATFORM_ANDROID
#ifdef PRE_ANDROID23
#include "main_android_java.h"
#else
#include "main_android.h"
#endif
#endif
#ifdef PLATFORM_RPI
#include "main_rpi.h"
#endif
int main() {
MinecraftClient minecraft(App::CreatePlatform());
minecraft.run();
return 0;
}

4
src/main_android.h
View File

@@ -250,10 +250,10 @@ static void pointerMove(int pointerId, int x, int y) {
Multitouch::feed(0, 0, x, y, pointerId);
}
__inline static const float padXtoSigned(int x) {
inline static const float padXtoSigned(int x) {
return (x - 483.0f) * 0.002070393374741201f;
}
__inline static const float padYtoSigned(int y) {
inline static const float padYtoSigned(int y) {
return (y - 180.0f) * 0.005555555555555556f;
}

45
src/main_dedicated.cpp
View File

@@ -1,20 +1,22 @@
#include <iostream>
#include "NinecraftApp.h"
#include "AppPlatform.h"
#include <IPlatform.h>
#include <memory>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include "MinecraftServer.h"
#include "platform/server/PlatformServer.h"
#include "world/level/LevelSettings.h"
#include "world/level/Level.h"
#include "server/ArgumentsSettings.h"
#include "platform/time.h"
#include "SharedConstants.h"
#define MAIN_CLASS NinecraftApp
static App* g_app = 0;
static int g_exitCode = 0;
void signal_callback_handler(int signum) {
std::cout << "Signum caught: " << signum << std::endl;
if(signum == 2 || signum == 3){ // SIGINT || SIGQUIT
@@ -29,6 +31,7 @@ void signal_callback_handler(int signum) {
int main(int numArguments, char* pszArgs[]) {
ArgumentsSettings aSettings(numArguments, pszArgs);
if(aSettings.getShowHelp()) {
ArgumentsSettings defaultSettings(0, NULL);
printf("Minecraft Pockect Edition Server %s\n", Common::getGameVersionString("").c_str());
@@ -43,34 +46,34 @@ int main(int numArguments, char* pszArgs[]) {
printf("-------------------------------------------------------\n");
return 0;
}
printf("Level Name: %s\n", aSettings.getLevelName().c_str());
AppContext appContext;
appContext.platform = new AppPlatform();
App* app = new MAIN_CLASS();
signal(SIGINT, signal_callback_handler);
g_app = app;
((MAIN_CLASS*)g_app)->externalStoragePath = aSettings.getExternalPath();
((MAIN_CLASS*)g_app)->externalCacheStoragePath = aSettings.getCachePath();
g_app->init(appContext);
printf("Level Name: %s\n", aSettings.getLevelName().c_str());
MinecraftServer server(App::CreatePlatform());
signal(SIGINT, signal_callback_handler);
g_app = &server;
server.externalStoragePath = aSettings.getExternalPath();
server.externalCacheStoragePath = aSettings.getCachePath();
server.init();
LevelSettings settings(getEpochTimeS(), GameType::Creative);
float startTime = getTimeS();
((MAIN_CLASS*)g_app)->selectLevel(aSettings.getLevelDir(), aSettings.getLevelName(), settings);
((MAIN_CLASS*)g_app)->hostMultiplayer(aSettings.getPort());
server.selectLevel(aSettings.getLevelDir(), aSettings.getLevelName(), settings);
server.hostMultiplayer(aSettings.getPort());
std::cout << "Level has been generated in " << getTimeS() - startTime << std::endl;
((MAIN_CLASS*)g_app)->level->saveLevelData();
server.level->saveLevelData();
std::cout << "Level has been saved!" << std::endl;
while(!app->wantToQuit()) {
app->update();
while(!server.wantToQuit()) {
server.update();
//pthread_yield();
sleepMs(20);
}
((MAIN_CLASS*)g_app)->level->saveLevelData();
delete app;
appContext.platform->finish();
delete appContext.platform;
server.level->saveLevelData();
std::cout << "Quit correctly" << std::endl;
return g_exitCode;

198
src/main_glfw.h
View File

@@ -2,6 +2,7 @@
#define MAIN_GLFW_H__
#include "App.h"
#include "NinecraftApp.h"
#include "client/renderer/entity/PlayerRenderer.h"
#include "client/renderer/gles.h"
#include "GLFW/glfw3.h"
@@ -16,203 +17,56 @@
#ifdef __EMSCRIPTEN__
#include <emscripten/emscripten.h>
#endif
static App* g_app = 0;
int transformKey(int glfwkey) {
if (glfwkey >= GLFW_KEY_F1 && glfwkey <= GLFW_KEY_F12) {
return glfwkey - 178;
}
// void loop() {
// using clock = std::chrono::steady_clock;
// auto frameStart = clock::now();
switch (glfwkey) {
case GLFW_KEY_ESCAPE: return Keyboard::KEY_ESCAPE;
case GLFW_KEY_TAB: return Keyboard::KEY_TAB;
case GLFW_KEY_BACKSPACE: return Keyboard::KEY_BACKSPACE;
case GLFW_KEY_LEFT_SHIFT: return Keyboard::KEY_LSHIFT;
case GLFW_KEY_ENTER: return Keyboard::KEY_RETURN;
case GLFW_KEY_LEFT_CONTROL: return Keyboard::KEY_LEFT_CTRL;
default: return glfwkey;
}
}
// g_app->update();
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
if(action == GLFW_REPEAT) return;
// glfwSwapBuffers(((AppPlatform_glfw*)g_app->platform())->window);
// glfwPollEvents();
if (key == GLFW_KEY_F11 && action == GLFW_PRESS) {
GLFWmonitor* monitor = glfwGetWindowMonitor(window);
if (monitor) {
// Currently fullscreen → go windowed
glfwSetWindowMonitor(window, NULL, 80, 80, 854, 480, 0);
} else {
// Currently windowed → go fullscreen on primary monitor
GLFWmonitor* primary = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(primary);
glfwSetWindowMonitor(window, primary, 0, 0, mode->width, mode->height, mode->refreshRate);
}
return;
}
Keyboard::feed(transformKey(key), action);
}
void character_callback(GLFWwindow* window, unsigned int codepoint) {
Keyboard::feedText(codepoint);
}
static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
static double lastX = 0.0, lastY = 0.0;
static bool firstMouse = true;
if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}
double deltaX = xpos - lastX;
double deltaY = ypos - lastY;
lastX = xpos;
lastY = ypos;
if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED) {
Mouse::feed(0, 0, xpos, ypos, deltaX, deltaY);
} else {
Mouse::feed( MouseAction::ACTION_MOVE, 0, xpos, ypos);
}
Multitouch::feed(0, 0, xpos, ypos, 0);
}
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
if(action == GLFW_REPEAT) return;
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
if (button == GLFW_MOUSE_BUTTON_LEFT) {
Mouse::feed( MouseAction::ACTION_LEFT, action, xpos, ypos);
Multitouch::feed(1, action, xpos, ypos, 0);
}
if (button == GLFW_MOUSE_BUTTON_RIGHT) {
Mouse::feed( MouseAction::ACTION_RIGHT, action, xpos, ypos);
}
}
void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
Mouse::feed(3, 0, xpos, ypos, 0, yoffset);
}
void window_size_callback(GLFWwindow* window, int width, int height) {
if (g_app) g_app->setSize(width, height);
}
void error_callback(int error, const char* desc) {
printf("Error: %s\n", desc);
}
void loop() {
using clock = std::chrono::steady_clock;
auto frameStart = clock::now();
g_app->update();
glfwSwapBuffers(((AppPlatform_glfw*)g_app->platform())->window);
glfwPollEvents();
glfwSwapInterval(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
auto frameEnd = clock::now();
auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
auto target = std::chrono::microseconds(33333); // ~30 fps
if(elapsed < target)
std::this_thread::sleep_for(target - elapsed);
}
}
// glfwSwapInterval(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
// if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
// auto frameEnd = clock::now();
// auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
// auto target = std::chrono::microseconds(33333); // ~30 fps
// if(elapsed < target)
// std::this_thread::sleep_for(target - elapsed);
// }
// }
int main(void) {
AppContext appContext;
#ifndef STANDALONE_SERVER
// Platform init.
appContext.platform = new AppPlatform_glfw();
#if defined(__EMSCRIPTEN__)
EM_ASM(
FS.mkdir('/games');
FS.mkdir('/games/com.mojang');
FS.mkdir('/games/com.mojang/minecraftWorlds');
FS.mount(IDBFS, {}, '/games');
FS.syncfs(true, function (err) {});
);
#endif
appContext.platform = new AppPlatformGlfw();
glfwSetErrorCallback(error_callback);
AppPlatformGlfw* platform = (AppPlatformGlfw*)appContext.platform;
if (!glfwInit()) {
if (!platform->init()) {
return 1;
}
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
#ifndef __EMSCRIPTEN__
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
#else
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#endif
App* app = (App*)new NinecraftApp();
app->init(appContext);
app->setSize(platform->getScreenWidth(), platform->getScreenHeight());
AppPlatform_glfw* platform = (AppPlatform_glfw*)appContext.platform;
platform->window = glfwCreateWindow(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight(), "Minecraft PE 0.6.1", NULL, NULL);
if (platform->window == NULL) {
return 1;
}
glfwSetKeyCallback(platform->window, key_callback);
glfwSetCharCallback(platform->window, character_callback);
glfwSetCursorPosCallback(platform->window, cursor_position_callback);
glfwSetMouseButtonCallback(platform->window, mouse_button_callback);
glfwSetScrollCallback(platform->window, scroll_callback);
glfwSetWindowSizeCallback(platform->window, window_size_callback);
glfwMakeContextCurrent(platform->window);
#ifndef __EMSCRIPTEN__
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
glfwSwapInterval(0);
#endif
#endif
App* app = new MAIN_CLASS();
g_app = app;
((MAIN_CLASS*)g_app)->externalStoragePath = ".";
((MAIN_CLASS*)g_app)->externalCacheStoragePath = ".";
g_app->init(appContext);
g_app->setSize(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight());
auto loop = [app]() {
app->update();
};
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop(loop, 0, 1);
#else
// Main event loop
while(!glfwWindowShouldClose(platform->window) && !app->wantToQuit()) {
while(!app->wantToQuit()) {
loop();
}
#endif
delete app;
#ifndef STANDALONE_SERVER
// Exit.
glfwDestroyWindow(platform->window);
glfwTerminate();
#endif
appContext.platform->finish();
delete appContext.platform;

2
src/nbt/CompoundTag.h
View File

@@ -115,7 +115,7 @@ public:
return it->second;
}
__inline bool contains(const std::string& name) const {
inline bool contains(const std::string& name) const {
return tags.find(name) != tags.end();
}
bool contains(const std::string& name, int type) const {

129
src/network/ClientSideNetworkHandler.cpp
View File

@@ -1,6 +1,7 @@
#include "ClientSideNetworkHandler.h"
#include <MinecraftClient.h>
#include "client/Options.h"
#include "gamemode/GameMode.h"
#include "packet/PacketInclude.h"
#include "RakNetInstance.h"
#include "../world/level/chunk/ChunkSource.h"
@@ -8,11 +9,7 @@
#include "../world/level/storage/LevelStorageSource.h"
#include "../world/entity/player/Player.h"
#include "../world/entity/player/Inventory.h"
#include "../client/Minecraft.h"
#include "../client/gamemode/GameMode.h"
#ifndef STANDALONE_SERVER
#include "../client/gui/screens/DisconnectionScreen.h"
#endif
#include <Minecraft.h>
#include "../client/player/LocalPlayer.h"
#include "../client/multiplayer/MultiPlayerLevel.h"
#include "../client/player/input/KeyboardInput.h"
@@ -22,9 +19,6 @@
#include "../world/level/Explosion.h"
#include "../world/level/tile/entity/FurnaceTileEntity.h"
#include "../world/inventory/BaseContainerMenu.h"
#ifndef STANDALONE_SERVER
#include "../client/particle/TakeAnimationParticle.h"
#endif
#include "../world/entity/EntityFactory.h"
#include "../world/entity/item/PrimedTnt.h"
#include "../world/entity/projectile/Arrow.h"
@@ -35,12 +29,9 @@
static MultiPlayerLevel* mpcast(Level* l) { return (MultiPlayerLevel*) l; }
ClientSideNetworkHandler::ClientSideNetworkHandler(Minecraft* minecraft, IRakNetInstance* raknetInstance)
ClientSideNetworkHandler::ClientSideNetworkHandler(MinecraftClient& minecraft, IRakNetInstance* raknetInstance)
: minecraft(minecraft),
raknetInstance(raknetInstance),
level(NULL),
requestNextChunkPosition(0),
requestNextChunkIndex(0)
raknetInstance(raknetInstance)
{
rakPeer = raknetInstance->getPeer();
}
@@ -86,7 +77,7 @@ void ClientSideNetworkHandler::onConnect(const RakNet::RakNetGUID& hostGuid)
serverGuid = hostGuid;
clearChunksLoaded();
LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion);
LoginPacket packet(minecraft.options().getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion);
raknetInstance->send(packet);
}
@@ -103,14 +94,14 @@ void ClientSideNetworkHandler::onDisconnect(const RakNet::RakNetGUID& guid)
level->isClientSide = false;
for (int i = (int)level->players.size()-1; i >= 0; --i ) {
Player* p = level->players[i];
if (p != minecraft->player) {
if (p != minecraft.getPlayer()) {
p->reallyRemoveIfPlayer = true;
level->removeEntity(p);
}
}
}
#ifndef STANDALONE_SERVER
minecraft->gui.addMessage("Disconnected from server");
minecraft.gui.addMessage("Disconnected from server");
#endif
}
@@ -123,13 +114,13 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginSta
if (packet->status == LoginStatus::Failed_ClientOld) {
LOGI("Disconnect! Client is outdated!\n");
#ifndef STANDALONE_SERVER
minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated client!"));
minecraft.setScreen(new DisconnectionScreen("Could not connect: Outdated client!"));
#endif
}
if (packet->status == LoginStatus::Failed_ServerOld) {
LOGI("Disconnect! Server is outdated!\n");
#ifndef STANDALONE_SERVER
minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated server!"));
minecraft.setScreen(new DisconnectionScreen("Could not connect: Outdated server!"));
#endif
}
}
@@ -141,13 +132,13 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
#ifdef RPI
if (packet->gameType != GameType::Creative) {
minecraft->setScreen(new DisconnectionScreen("Could not connect: Incompatible server!"));
minecraft.setScreen(new DisconnectionScreen("Could not connect: Incompatible server!"));
return;
}
#endif
const std::string& levelId = LevelStorageSource::TempLevelId;
LevelStorageSource* storageSource = minecraft->getLevelSource();
LevelStorageSource* storageSource = minecraft.getLevelSource();
storageSource->deleteLevel(levelId);
//level = new Level(storageSource->selectLevel(levelId, true), "temp", packet->levelSeed, SharedConstants::StorageVersion);
MultiPlayerLevel* level = new MultiPlayerLevel(
@@ -158,22 +149,22 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
level->isClientSide = true;
bool isCreative = (packet->gameType == GameType::Creative);
LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreative);
LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft.options().getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreative);
player->owner = rakPeer->GetMyGUID();
player->entityId = packet->entityId;
player->moveTo(packet->x, packet->y, packet->z, player->yRot, player->xRot);
LOGI("new pos: %f, %f [%f - %f]\n", player->x, player->z, player->bb.y0, player->bb.y1);
minecraft->setLevel(level, "ClientSideNetworkHandler -> setLevel", player);
minecraft->setIsCreativeMode(isCreative);
minecraft.setLevel(level, "ClientSideNetworkHandler -> setLevel", player);
minecraft.setIsCreativeMode(isCreative);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MessagePacket* packet)
{
LOGI("MessagePacket\n");
#ifndef STANDALONE_SERVER
minecraft->gui.addMessage(packet->message.C_String());
minecraft.gui.addMessage(packet->message.C_String());
#endif
}
@@ -270,8 +261,8 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AddPlaye
}
LOGI("AddPlayerPacket\n");
Player* player = new RemotePlayer(level, minecraft->isCreativeMode());
minecraft->gameMode->initAbilities(player->abilities);
Player* player = new RemotePlayer(level, minecraft.isCreativeMode());
minecraft.gameMode->initAbilities(player->abilities);
player->entityId = packet->entityId;
level->addEntity(player);
@@ -292,12 +283,12 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AddPlaye
std::string message = packet->name.C_String();
message += " joined the game";
#ifndef STANDALONE_SERVER
minecraft->gui.addMessage(message);
minecraft.gui.addMessage(message);
#endif
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemovePlayerPacket* packet) {
if (!level || source == minecraft->player->owner) return;
if (!level || source == minecraft.getPlayer()->owner) return;
if (Player* player = findPlayer(level, packet->entityId, &packet->owner)) {
player->reallyRemoveIfPlayer = true;
@@ -316,7 +307,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemovePl
//std::string message = packet->name.C_String();
//message += " joined the game";
//minecraft->gui.addMessage(message);
//minecraft.gui.addMessage(message);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveEntityPacket* packet)
@@ -324,7 +315,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveEn
if (!level) return;
Entity* entity = level->getEntity(packet->entityId);
LOGI("RemoveEntityPacket %p %p, %d\n", entity, minecraft->player, entity?(int)(entity->isPlayer()): -1);
LOGI("RemoveEntityPacket %p %p, %d\n", entity, minecraft.getPlayer(), entity?(int)(entity->isPlayer()): -1);
if (!entity) return;
level->removeEntity(entity);
@@ -355,7 +346,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItem
item = ((ItemEntity*) e)->item;
#ifndef STANDALONE_SERVER
if (Entity* to = level->getEntity(packet->playerId))
minecraft->particleEngine->add(new TakeAnimationParticle(level, (ItemEntity*)e, to, -0.5f));
minecraft.particleEngine->add(new TakeAnimationParticle(level, (ItemEntity*)e, to, -0.5f));
#endif
}
else if (e->getEntityTypeId() == EntityTypes::IdArrow)
@@ -365,10 +356,10 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItem
return;
// try take it and if we don't have space; re-throw it
if (minecraft->player->entityId == packet->playerId
&& !minecraft->player->inventory->add(&item)) {
if (minecraft.getPlayer()->entityId == packet->playerId
&& !minecraft.getPlayer()->inventory->add(&item)) {
DropItemPacket dropPacket(packet->playerId, item);
minecraft->raknetInstance->send(dropPacket);
minecraft.raknetInstance->send(dropPacket);
}
level->playSound(e, "random.pop", 0.2f, 1.0f * 2.f);
}
@@ -438,16 +429,16 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ExplodeP
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LevelEventPacket* packet) {
if (!level) return;
if(packet->eventId == LevelEvent::ALL_PLAYERS_SLEEPING) {
minecraft->player->setAllPlayersSleeping();
minecraft.getPlayer()->setAllPlayersSleeping();
}
else {
minecraft->level->levelEvent(NULL, packet->eventId, packet->x, packet->y, packet->z, packet->data);
minecraft.level->levelEvent(NULL, packet->eventId, packet->x, packet->y, packet->z, packet->data);
}
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TileEventPacket* packet) {
if (!level) return;
minecraft->level->tileEvent(packet->x, packet->y, packet->z, packet->b0, packet->b1);
minecraft.level->tileEvent(packet->x, packet->y, packet->z, packet->b0, packet->b1);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, EntityEventPacket* packet) {
@@ -631,7 +622,7 @@ void ClientSideNetworkHandler::arrangeRequestChunkOrder() {
int cz = CHUNK_CACHE_WIDTH / 2;
// If player exists, let's sort around him
Player* p = minecraft? minecraft->player : NULL;
Player* p = minecraft.getPlayer();
if (p) {
cx = Mth::floor(p->x / (float)CHUNK_WIDTH);
cz = Mth::floor(p->z / (float)CHUNK_DEPTH);
@@ -717,9 +708,9 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Interact
{
Player* player = (Player*) src;
if (InteractPacket::Attack == packet->action)
minecraft->gameMode->attack(player, entity);
minecraft.gameMode->attack(player, entity);
if (InteractPacket::Interact == packet->action)
minecraft->gameMode->interact(player, entity);
minecraft.gameMode->interact(player, entity);
}
}
@@ -759,7 +750,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
return;
// Own player - Then don't play... :
if (minecraft->player->entityId == packet->entityId) {
if (minecraft.getPlayer()->entityId == packet->entityId) {
if (packet->action == AnimatePacket::Swing) return;
}
@@ -788,26 +779,26 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SetHealthPacket* packet)
{
if (!level || !minecraft->player)
if (!level || !minecraft.getPlayer())
return;
minecraft->player->hurtTo(packet->health);
minecraft.getPlayer()->hurtTo(packet->health);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SetSpawnPositionPacket* packet) {
if (!level || !minecraft || !minecraft->player) return;
if (!level || !minecraft.getPlayer()) return;
if (!level->inRange(packet->x, packet->y, packet->z)) return;
minecraft->player->setRespawnPosition(Pos(packet->x, packet->y, packet->z));
minecraft.getPlayer()->setRespawnPosition(Pos(packet->x, packet->y, packet->z));
level->getLevelData()->setSpawn(packet->x, packet->y, packet->z);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, HurtArmorPacket* packet) {
if (!level || !minecraft->player) {
if (!level || !minecraft.getPlayer()) {
return;
}
minecraft->player->hurtArmor(packet->dmg);
minecraft.getPlayer()->hurtArmor(packet->dmg);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RespawnPacket* packet)
@@ -820,43 +811,43 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RespawnP
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerOpenPacket* packet)
{
if (!level || !minecraft || !minecraft->player)
if (!level)
return;
if (packet->type == ContainerType::FURNACE) {
FurnaceTileEntity* te = new FurnaceTileEntity();
te->clientSideOnly = true;
minecraft->player->openFurnace(te);
if (minecraft->player->containerMenu)
minecraft->player->containerMenu->containerId = packet->containerId;
minecraft.getPlayer()->openFurnace(te);
if (minecraft.getPlayer()->containerMenu)
minecraft.getPlayer()->containerMenu->containerId = packet->containerId;
}
if (packet->type == ContainerType::CONTAINER) {
ChestTileEntity* te = new ChestTileEntity();
te->clientSideOnly = true;
minecraft->player->openContainer(te);
if (minecraft->player->containerMenu)
minecraft->player->containerMenu->containerId = packet->containerId;
minecraft.getPlayer()->openContainer(te);
if (minecraft.getPlayer()->containerMenu)
minecraft.getPlayer()->containerMenu->containerId = packet->containerId;
}
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerClosePacket* packet)
{
if (minecraft && minecraft->player && minecraft->player->containerMenu)
minecraft->player->closeContainer();
if (minecraft.getPlayer() && minecraft.getPlayer()->containerMenu)
minecraft.getPlayer()->closeContainer();
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetContentPacket* packet)
{
if (!minecraft || !minecraft->player)
if (!minecraft.getPlayer())
return;
if (packet->containerId == 0) {
for (unsigned int i = 0; i < packet->items.size(); ++i) {
minecraft->player->inventory->setItem(Inventory::MAX_SELECTION_SIZE + i, &packet->items[i]);
minecraft.getPlayer()->inventory->setItem(Inventory::MAX_SELECTION_SIZE + i, &packet->items[i]);
}
} else if (minecraft->player->containerMenu && minecraft->player->containerMenu->containerId == packet->containerId) {
} else if (minecraft.getPlayer()->containerMenu && minecraft.getPlayer()->containerMenu->containerId == packet->containerId) {
for (unsigned int i = 0; i < packet->items.size(); ++i) {
minecraft->player->containerMenu->setSlot(i, &packet->items[i]);
minecraft.getPlayer()->containerMenu->setSlot(i, &packet->items[i]);
}
}
}
@@ -865,28 +856,28 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
{
//LOGI("ContainerSetSlot\n");
if (!minecraft->player
|| !minecraft->player->containerMenu
|| minecraft->player->containerMenu->containerId != packet->containerId)
if (!minecraft.getPlayer()
|| !minecraft.getPlayer()->containerMenu
|| minecraft.getPlayer()->containerMenu->containerId != packet->containerId)
return;
//minecraft->player->containerMenu->setSlot(packet->slot, packet->item.isNull()? NULL : &packet->item);
minecraft->player->containerMenu->setSlot(packet->slot, &packet->item);
//minecraft.getPlayer()->containerMenu->setSlot(packet->slot, packet->item.isNull()? NULL : &packet->item);
minecraft.getPlayer()->containerMenu->setSlot(packet->slot, &packet->item);
}
void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetDataPacket* packet)
{
//LOGI("ContainerSetData\n");
if (minecraft->player && minecraft->player->containerMenu && minecraft->player->containerMenu->containerId == packet->containerId) {
if (minecraft.getPlayer() && minecraft.getPlayer()->containerMenu && minecraft.getPlayer()->containerMenu->containerId == packet->containerId) {
//LOGI("client: SetData2 %d, %d\n", packet->id, packet->value);
minecraft->player->containerMenu->setData(packet->id, packet->value);
minecraft.getPlayer()->containerMenu->setData(packet->id, packet->value);
}
}
void ClientSideNetworkHandler::handle( const RakNet::RakNetGUID& source, ChatPacket* packet )
{
#ifndef STANDALONE_SERVER
minecraft->gui.displayClientMessage(packet->message);
minecraft.gui.displayClientMessage(packet->message);
#endif
}

12
src/network/ClientSideNetworkHandler.h
View File

@@ -8,7 +8,7 @@
#include <vector>
class Minecraft;
class MinecraftClient;
class Level;
class IRakNetInstance;
@@ -29,7 +29,7 @@ typedef struct IntPair {
class ClientSideNetworkHandler : public NetEventCallback
{
public:
ClientSideNetworkHandler(Minecraft* minecraft, IRakNetInstance* raknetInstance);
ClientSideNetworkHandler(MinecraftClient& minecraft, IRakNetInstance* raknetInstance);
virtual ~ClientSideNetworkHandler();
virtual void levelGenerated(Level* level);
@@ -87,19 +87,19 @@ private:
void clearChunksLoaded();
private:
Minecraft* minecraft;
Level* level;
MinecraftClient& minecraft;
Level* level = nullptr;
IRakNetInstance* raknetInstance;
RakNet::RakPeerInterface* rakPeer;
RakNet::RakNetGUID serverGuid;
BlockUpdateList bufferedBlockUpdates;
int requestNextChunkPosition;
int requestNextChunkPosition = 0;
static const int NumRequestChunks = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
int requestNextChunkIndex;
int requestNextChunkIndex = 0;
IntPair requestNextChunkIndexList[NumRequestChunks];
bool chunksLoaded[NumRequestChunks];
};

3
src/network/RakNetInstance.cpp
View File

@@ -5,11 +5,10 @@
#include "../raknet/BitStream.h"
#include "../raknet/MessageIdentifiers.h"
#include "../raknet/GetTime.h"
#include "../AppConstants.h"
#include "../platform/log.h"
#define APP_IDENTIFIER "MCCPP;" APP_VERSION_STRING ";"
#define APP_IDENTIFIER "MCCPP;Demo;"
#define APP_IDENTIFIER_MINECON "MCCPP;MINECON;"
RakNetInstance::RakNetInstance()

94
src/network/ServerSideNetworkHandler.cpp
View File

@@ -5,19 +5,53 @@
#include "../world/entity/player/Inventory.h"
#include "../world/Container.h"
#include "../world/inventory/BaseContainerMenu.h"
#include "packet/PacketInclude.h"
#include "MinecraftClient.h"
#include "gamemode/GameMode.h"
#include "RakNetInstance.h"
#include "../client/Minecraft.h"
#include <MinecraftClient.h>
#include "../client/player/LocalPlayer.h"
#include "../client/gamemode/GameMode.h"
#include "../raknet/RakPeerInterface.h"
#include "../raknet/PacketPriority.h"
#ifndef STANDALONE_SERVER
#include "../client/sound/SoundEngine.h"
#endif
#include "../server/ServerPlayer.h"
#include "../world/entity/item/FallingTile.h"
#include "network/packet/AddEntityPacket.h"
#include "network/packet/AddItemEntityPacket.h"
#include "network/packet/AddMobPacket.h"
#include "network/packet/AddPaintingPacket.h"
#include "network/packet/AddPlayerPacket.h"
#include "network/packet/AdventureSettingsPacket.h"
#include "network/packet/AnimatePacket.h"
#include "network/packet/ChatPacket.h"
#include "network/packet/ChunkDataPacket.h"
#include "network/packet/ContainerSetSlotPacket.h"
#include "network/packet/DropItemPacket.h"
#include "network/packet/EntityEventPacket.h"
#include "network/packet/InteractPacket.h"
#include "network/packet/LevelEventPacket.h"
#include "network/packet/LoginPacket.h"
#include "network/packet/LoginStatusPacket.h"
#include "network/packet/MessagePacket.h"
#include "network/packet/MovePlayerPacket.h"
#include "network/packet/PlayerActionPacket.h"
#include "network/packet/PlayerArmorEquipmentPacket.h"
#include "network/packet/PlayerEquipmentPacket.h"
#include "network/packet/ReadyPacket.h"
#include "network/packet/RemoveBlockPacket.h"
#include "network/packet/RemoveEntityPacket.h"
#include "network/packet/RemovePlayerPacket.h"
#include "network/packet/RequestChunkPacket.h"
#include "network/packet/RespawnPacket.h"
#include "network/packet/SendInventoryPacket.h"
#include "network/packet/SetHealthPacket.h"
#include "network/packet/SetTimePacket.h"
#include "network/packet/SignUpdatePacket.h"
#include "network/packet/StartGamePacket.h"
#include "network/packet/TileEventPacket.h"
#include "network/packet/UpdateBlockPacket.h"
#include "network/packet/UseItemPacket.h"
#include "world/entity/Painting.h"
#include "world/level/tile/entity/TileEntity.h"
#define TIMES(x) for(int itc ## __LINE__ = 0; itc ## __LINE__ < x; ++ itc ## __LINE__)
@@ -52,16 +86,19 @@ void ServerSideNetworkHandler::tileChanged(int x, int y, int z)
}
Packet* ServerSideNetworkHandler::getAddPacketFromEntity( Entity* entity ) {
if (entity->isMob() && !entity->isPlayer()) { //@fix: This code is duplicated. See if it can be unified.
if (minecraft->player) {
// I guess this should always be true, but it crashed somewhere in this
// function once and I only see this one as a potential problem
return new AddMobPacket((Mob*)entity);
}
}
else if (entity->isPlayer()) {
// if (entity->isMob() && !entity->isPlayer()) { //@fix: This code is duplicated. See if it can be unified.
// auto client = dynamic_cast<MinecraftClient*>(minecraft);
} else if (entity->isItemEntity()) {
// if (client && client->getPlayer()) {
// // I guess this should always be true, but it crashed somewhere in this
// // function once and I only see this one as a potential problem
// return new AddMobPacket((Mob*)entity);
// }
// }
// else if (entity->isPlayer()) {
// } else
if (entity->isItemEntity()) {
AddItemEntityPacket* packet = new AddItemEntityPacket((ItemEntity*)entity);
entity->xd = packet->xa();
entity->yd = packet->ya();
@@ -409,9 +446,11 @@ void ServerSideNetworkHandler::levelGenerated( Level* level )
{
this->level = level;
if (minecraft->player) {
minecraft->player->owner = rakPeer->GetMyGUID();
}
// auto client = dynamic_cast<MinecraftClient*>(minecraft);
// if (client && client->getPlayer()) {
// client->getPlayer()->owner = rakPeer->GetMyGUID();
// }
level->addListener(this);
#ifndef STANDALONE_SERVER
@@ -485,10 +524,12 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
if (!level)
return;
// Own player -> invalid
if (minecraft->player && minecraft->player->entityId == packet->entityId) {
return;
}
// auto client = dynamic_cast<MinecraftClient*>(minecraft);
// // Own player -> invalid
// if (client && client->getPlayer() && client->getPlayer()->entityId == packet->entityId) {
// return;
// }
Entity* entity = level->getEntity(packet->entityId);
if (!entity || !entity->isPlayer())
@@ -605,8 +646,11 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
Player* p = findPlayer(level, &source);
if (!p) return;
if (p != minecraft->player)
static_cast<ServerPlayer*>(p)->doCloseContainer();
// // if (p != minecraft->player)
// static_cast<ServerPlayer*>(p)->doCloseContainer();
if (auto sp = dynamic_cast<ServerPlayer*>(p))
sp->doCloseContainer();
}
void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetSlotPacket* packet) {
@@ -672,7 +716,7 @@ void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SignUpd
void ServerSideNetworkHandler::allowIncomingConnections( bool doAllow )
{
if (doAllow) {
raknetInstance->announceServer(minecraft->options.getStringValue(OPTIONS_USERNAME));
raknetInstance->announceServer(minecraft->getServerName());
} else {
raknetInstance->announceServer("");
}

31
src/network/command/CommandServer.cpp
View File

@@ -1,7 +1,8 @@
#include "CommandServer.h"
#include "../../client/Minecraft.h"
#include <Minecraft.h>
#include "../../world/level/Level.h"
#include "../../world/entity/Entity.h"
#include "gamemode/CreatorMode.h"
#ifdef WIN32
#define SERR(x) (WSA ## x)
@@ -14,10 +15,8 @@
#include "../RakNetInstance.h"
#include "../packet/ChatPacket.h"
#include "../packet/AdventureSettingsPacket.h"
#include "../../world/level/LevelSettings.h"
#include "../../world/entity/player/Player.h"
#include "../../client/gamemode/CreatorMode.h"
#include "../../client/player/LocalPlayer.h"
#include <world/level/LevelSettings.h>
#include <world/entity/player/Player.h>
#include "../RakNetInstance.h"
const std::string NullString;
@@ -262,6 +261,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
return ToStringOk(y);
}
#if 0
//
// Player related get, set and query
//
@@ -316,6 +316,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
apiPosTranslate.to(x, y, z);
return ToStringOk(x, y, z);
}
#endif
//
// Entity
@@ -385,6 +386,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
return NullString;
}
#if 0
//
// Camera
//
@@ -430,6 +432,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
e->moveTo((float)x + 0.5f, (float)y, (float)z + 0.5f, e->yRot, e->xRot);
return NullString;
}
#endif
//
// Entities
@@ -445,6 +448,8 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
return s.str();
}
#if 0
//
// Set and restore Checkpoint
//
@@ -478,6 +483,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
}
return success? NullString : Fail;
}
#endif
//
// Event queries
@@ -540,9 +546,9 @@ void CommandServer::tick() {
_updateClients();
++t;
if (mc->cameraTargetPlayer == camera) {
camera->tick();
}
// if (mc->cameraTargetPlayer == camera) {
// camera->tick();
// }
}
void CommandServer::_updateAccept() {
@@ -587,9 +593,9 @@ bool CommandServer::_updateClient(ConnectedClient& client) {
}
void CommandServer::dispatchPacket( Packet& p ) {
if (!mc->netCallback || !mc->player) return;
const RakNet::RakNetGUID& guid = ((Player*)mc->player)->owner;
mc->raknetInstance->send(p);
// if (!mc->netCallback || !mc->player) return;
// const RakNet::RakNetGUID& guid = ((Player*)mc->player)->owner;
// mc->raknetInstance->send(p);
//p.handle(guid, mc->netCallback);
}
@@ -609,6 +615,7 @@ std::string CommandServer::handleEventPollMessage( ConnectedClient& client, cons
ICreator::EventList<ICreator::TileEvent>& events = c->getTileEvents();
std::stringstream ss;
events.write(ss, apiPosTranslate, client.lastPoll_blockHit);
client.lastPoll_blockHit = mc->level->getTime();
@@ -630,7 +637,7 @@ std::string CommandServer::handleSetSetting( const std::string& setting, int val
{
bool status = value != 0;
if (setting == "autojump") mc->player->autoJumpEnabled = status;
// if (setting == "autojump") mc->player->autoJumpEnabled = status;
AdventureSettingsPacket::Flags flag = (AdventureSettingsPacket::Flags)0;
if (setting == "nametags_visible") flag = AdventureSettingsPacket::ShowNameTags;

6
src/AppPlatform_android.h → src/platform/android/AppPlatform_android.h
View File

@@ -1,7 +1,7 @@
#ifndef APPPLATFORM_ANDROID_H__
#define APPPLATFORM_ANDROID_H__
#include "AppPlatform.h"
#include <IPlatform.h>
#include "client/renderer/gles.h"
#include "platform/log.h"
#include "platform/time.h"
@@ -322,7 +322,7 @@ public:
}
}
__inline unsigned int rgbToBgr(unsigned int p) {
inline unsigned int rgbToBgr(unsigned int p) {
return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
}
@@ -536,7 +536,7 @@ public:
return env->CallBooleanMethod(instance, _methodIsNetworkEnabled, onlyWifiAllowed);
}
static __inline bool isSquare(int n) {
static inline bool isSquare(int n) {
int L = n & 0xf;
if (((1 << L) & 0x213) == 0) return false;

0
src/AppPlatform_android23.h → src/platform/android/AppPlatform_android23.h
View File

235
src/platform/glfw/PlatformGlfw.cpp Normal file
View File

@@ -0,0 +1,235 @@
#include "PlatformGlfw.h"
#include <IPlatform.h>
#include "platform/input/Keyboard.h"
#include "platform/input/Mouse.h"
#include "platform/log.h"
#include <GLFW/glfw3.h>
#include <png.h>
#include "platform/HttpClient.h"
#include "util/StringUtils.h"
#include <fstream>
#include <ctime>
#include <vector>
#ifdef _WIN32
#include <windows.h>
#include <shellapi.h>
#endif
#include "App.h"
bool PlatformGlfw::init() {
glfwSetErrorCallback(PlatformGlfw::error_callback);
if (!glfwInit()) {
return false;
}
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
#ifndef __EMSCRIPTEN__
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
#else
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
#endif
m_window = glfwCreateWindow(getScreenWidth(), getScreenHeight(), "Minecraft PE 0.6.1", NULL, NULL);
if (m_window == nullptr) {
return false;
}
glfwSetKeyCallback(m_window, key_callback);
glfwSetCharCallback(m_window, character_callback);
glfwSetCursorPosCallback(m_window, cursor_position_callback);
glfwSetMouseButtonCallback(m_window, mouse_button_callback);
glfwSetScrollCallback(m_window, scroll_callback);
glfwSetWindowSizeCallback(m_window, window_size_callback);
glfwSetWindowUserPointer(m_window, this);
glfwMakeContextCurrent(m_window);
#ifndef __EMSCRIPTEN__
gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
glfwSwapInterval(0);
#endif
}
void PlatformGlfw::finish() {
glfwDestroyWindow(m_window);
glfwTerminate();
}
int PlatformGlfw::transformKey(int glfwkey) {
if (glfwkey >= GLFW_KEY_F1 && glfwkey <= GLFW_KEY_F12) {
return glfwkey - 178;
}
switch (glfwkey) {
case GLFW_KEY_ESCAPE: return Keyboard::KEY_ESCAPE;
case GLFW_KEY_TAB: return Keyboard::KEY_TAB;
case GLFW_KEY_BACKSPACE: return Keyboard::KEY_BACKSPACE;
case GLFW_KEY_LEFT_SHIFT: return Keyboard::KEY_LSHIFT;
case GLFW_KEY_ENTER: return Keyboard::KEY_RETURN;
case GLFW_KEY_LEFT_CONTROL: return Keyboard::KEY_LEFT_CTRL;
default: return glfwkey;
}
}
void PlatformGlfw::cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
static double lastX = 0.0, lastY = 0.0;
static bool firstMouse = true;
if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}
double deltaX = xpos - lastX;
double deltaY = ypos - lastY;
lastX = xpos;
lastY = ypos;
if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED) {
Mouse::feed(0, 0, xpos, ypos, deltaX, deltaY);
} else {
Mouse::feed( MouseAction::ACTION_MOVE, 0, xpos, ypos);
}
// Multitouch::feed(0, 0, xpos, ypos, 0);
}
void PlatformGlfw::mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
if(action == GLFW_REPEAT) return;
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
if (button == GLFW_MOUSE_BUTTON_LEFT) {
Mouse::feed( MouseAction::ACTION_LEFT, action, xpos, ypos);
// Multitouch::feed(1, action, xpos, ypos, 0);
}
if (button == GLFW_MOUSE_BUTTON_RIGHT) {
Mouse::feed( MouseAction::ACTION_RIGHT, action, xpos, ypos);
}
}
void PlatformGlfw::character_callback(GLFWwindow* window, unsigned int codepoint) {
Keyboard::feedText(codepoint);
}
void PlatformGlfw::scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
Mouse::feed(3, 0, xpos, ypos, 0, yoffset);
}
void PlatformGlfw::error_callback(int error, const char* desc) {
LOGE("GLFW Error (%d): %s", error, desc);
}
void PlatformGlfw::window_size_callback(GLFWwindow* window, int width, int height) {
PlatformGlfw* app = (PlatformGlfw*)glfwGetWindowUserPointer(window);
app->windowSizeChanged = true;
}
float PlatformGlfw::getPixelsPerMillimeter() {
GLFWmonitor* monitor = glfwGetPrimaryMonitor();
int width_mm, height_mm;
glfwGetMonitorPhysicalSize(monitor, &width_mm, &height_mm);
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
return (float)mode->width / (float)width_mm;
}
TextureData PlatformGlfw::loadTexture(const std::string& filename_, bool textureFolder) {
// Support fetching PNG textures via HTTP/HTTPS (for skins, etc)
if (Util::startsWith(filename_, "http://") || Util::startsWith(filename_, "https://")) {
std::vector<unsigned char> body;
if (HttpClient::download(filename_, body) && !body.empty()) {
return loadTextureFromMemory(body.data(), body.size());
}
return TextureData();
}
TextureData out;
std::string filename = textureFolder? "data/images/" + filename_
: filename_;
std::ifstream source(filename.c_str(), std::ios::binary);
if (!source) {
LOGI("Couldn't find file: %s\n", filename.c_str());
return out;
}
std::vector<unsigned char> fileData((std::istreambuf_iterator<char>(source)), std::istreambuf_iterator<char>());
source.close();
if (fileData.empty()) {
LOGI("Couldn't read file: %s\n", filename.c_str());
return out;
}
return loadTextureFromMemory(fileData.data(), fileData.size());
}
std::string PlatformGlfw::getDateString(int s) {
time_t tm = s;
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%F %T", std::localtime(&tm));
return std::string(mbstr);
}
void PlatformGlfw::hideCursor(bool hide) {
int isHide = hide ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN;
glfwSetInputMode(m_window, GLFW_CURSOR, isHide);
}
void PlatformGlfw::openURL(const std::string& url) {
#ifdef _WIN32
ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
#elif __linux__
std::string command = "xdg-open " + url;
system(command.c_str());
#elif __EMSCRIPTEN__
emscripten_run_script(std::string("window.open('" + url + "', '_blank')").c_str());
#endif
}
void PlatformGlfw::swapBuffers() {
glfwSwapBuffers(m_window);
glfwPollEvents();
// @todo
// if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
// auto frameEnd = clock::now();
// auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
// auto target = std::chrono::microseconds(33333); // ~30 fps
// if(elapsed < target)
// std::this_thread::sleep_for(target - elapsed);
// }
}
void PlatformGlfw::setVSync(bool on) {
IPlatform::setVSync(on);
glfwSwapInterval(on);
}

75
src/platform/glfw/PlatformGlfw.h Executable file
View File

@@ -0,0 +1,75 @@
#ifndef APPPLATFORM_GLFW_H__
#define APPPLATFORM_GLFW_H__
#include <IPlatform.h>
#include "platform/log.h"
#include "platform/HttpClient.h"
#include "platform/PngLoader.h"
#include "client/renderer/gles.h"
#include "world/level/storage/FolderMethods.h"
#include <png.h>
#include <GLFW/glfw3.h>
#ifdef __EMSCRIPTEN__
#include <emscripten/html5.h>
#endif
class PlatformGlfw : public IPlatform {
public:
bool init() override;
void finish() override;
TextureData loadTexture(const std::string& filename_, bool textureFolder) override;
TextureData loadTextureFromMemory(const unsigned char* data, size_t size) override { return loadPngFromMemory(data, size); }
std::string getDateString(int s) override;
int getScreenWidth() override {
#ifdef __EMSCRIPTEN__
int w, h;
emscripten_get_canvas_element_size("canvas", &w, &h);
return w;
#endif
return 854;
};
int getScreenHeight() override {
#ifdef __EMSCRIPTEN__
int w, h;
emscripten_get_canvas_element_size("canvas", &w, &h);
return h;
#endif
return 480;
};
float getPixelsPerMillimeter() override;
bool supportsTouchscreen() override { return false; /* glfw supports only mouse and keyboard */ }
void hideCursor(bool hide) override;
void openURL(const std::string& url) override;
void swapBuffers() override;
void setVSync(bool on) override;
private:
static int transformKey(int glfwkey);
static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
static void character_callback(GLFWwindow* window, unsigned int codepoint);
static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos);
static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);
static void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);
static void window_size_callback(GLFWwindow* window, int width, int height);
static void error_callback(int error, const char* desc);
GLFWwindow* m_window;
};
#endif /*APPPLATFORM_GLFW_H__*/

4
src/AppPlatform_iOS.h → src/platform/ios/AppPlatform_iOS.h
View File

@@ -1,7 +1,7 @@
#ifndef APPPLATFORM_IOS_H__
#define APPPLATFORM_IOS_H__
#include "AppPlatform.h"
#include <IPlatform.h>
#include "client/renderer/gles.h"
#include "platform/log.h"
#include <cmath>
@@ -27,7 +27,7 @@ public:
//@todo
}
__inline unsigned int rgbToBgr(unsigned int p) {
inline unsigned int rgbToBgr(unsigned int p) {
return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
}

0
src/AppPlatform_iOS.mm → src/platform/ios/AppPlatform_iOS.mm
View File

23
src/platform/server/PlatformServer.cpp Normal file
View File

@@ -0,0 +1,23 @@
#include "PlatformServer.h"
#include <ctime>
#include "App.h"
#include "platform/time.h"
void PlatformServer::runMainLoop(App& app) {
while (!app.wantToQuit()) {
app.update();
sleepMs(20);
}
}
std::string PlatformServer::getDateString(int s) {
time_t tm = s;
char mbstr[100];
std::strftime(mbstr, sizeof(mbstr), "%F %T", std::localtime(&tm));
return std::string(mbstr);
}

16
src/platform/server/PlatformServer.h Executable file
View File

@@ -0,0 +1,16 @@
#pragma once
#include <IPlatform.h>
class PlatformServer : public IPlatform {
public:
void runMainLoop(App& app) override;
std::string getDateString(int s) override;
int getScreenWidth() override { return 0; }
int getScreenHeight() override { return 0; }
float getPixelsPerMillimeter() override { return 0.f; }
bool supportsTouchscreen() override { return false; }
std::string getPlatformStringVar(int stringId) override { return "Minecraft PE 0.6.1 Standalone Server"; }
};

0
src/AppPlatform_win32.cpp → src/platform/win32/AppPlatform_win32.cpp
View File

4
src/AppPlatform_win32.h → src/platform/win32/AppPlatform_win32.h
View File

@@ -1,7 +1,7 @@
#ifndef APPPLATFORM_WIN32_H__
#define APPPLATFORM_WIN32_H__
#include "AppPlatform.h"
#include <IPlatform.h>
#include "platform/log.h"
#include "platform/HttpClient.h"
#include "platform/PngLoader.h"
@@ -47,7 +47,7 @@ public:
//@todo
}
__inline unsigned int rgbToBgr(unsigned int p) {
inline unsigned int rgbToBgr(unsigned int p) {
return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
}

2
src/raknet/rdlmalloc.h
View File

@@ -1316,7 +1316,7 @@ inlining are defined as macros, so these aren't used for them.
#ifndef FORCEINLINE
#if defined(__GNUC__)
#define FORCEINLINE __inline __attribute__ ((always_inline))
#define FORCEINLINE inline __attribute__ ((always_inline))
#elif defined(_MSC_VER)
#define FORCEINLINE __forceinline
#endif

2
src/server/ServerPlayer.cpp
View File

@@ -10,7 +10,7 @@
#include "../network/packet/EntityEventPacket.h"
#include "../network/packet/SetHealthPacket.h"
#include "../network/packet/TakeItemEntityPacket.h"
#include "../client/Minecraft.h"
#include <Minecraft.h>
#include "../world/level/tile/entity/FurnaceTileEntity.h"
#include "../world/inventory/FurnaceMenu.h"
#include "../world/inventory/FillingContainer.h"

1052
src/terrain_4444.h
View File

File diff suppressed because it is too large Load Diff

1052
src/terrain_5551.h
View File

File diff suppressed because it is too large Load Diff

1052
src/terrain_565.h
View File

File diff suppressed because it is too large Load Diff

1052
src/terrain_565_2.h
View File

File diff suppressed because it is too large Load Diff

6
src/util/MemUtils.h
View File

@@ -10,10 +10,10 @@ public:
void inc() { ++_count; }
void dec() { if (--_count == 0 && _obj) delete _obj; }
__inline short refCount() { return _count; }
__inline bool isUnique() { return _count == 1; }
inline short refCount() { return _count; }
inline bool isUnique() { return _count == 1; }
__inline T* obj() { return _obj; }
inline T* obj() { return _obj; }
T& operator->() { return *_obj; }
void operator++() { inc(); }

2
src/util/Mth.cpp
View File

@@ -25,7 +25,7 @@ namespace Mth
return ret;
}
static __inline float fastInvSqrt(float x) {
static inline float fastInvSqrt(float x) {
float xhalf = 0.5f*x;
int i = *(int*)&x;
i = 0x5f3759df - (i>>1);

2
src/util/PerfRenderer.cpp
View File

@@ -5,7 +5,7 @@
#include "../client/gui/Font.h"
#include "../client/renderer/gles.h"
#include "../client/renderer/Tesselator.h"
#include "../client/Minecraft.h"
#include <Minecraft.h>
PerfRenderer::PerfRenderer( Minecraft* mc, Font* font )
: _mc(mc),

2
src/world/Pos.h
View File

@@ -26,7 +26,7 @@ public:
z(position.z)
{}
__inline bool operator==(const Pos& rhs) const {
inline bool operator==(const Pos& rhs) const {
return x == rhs.x && y == rhs.y && z == rhs.z;
}

2
src/world/entity/Entity.h
View File

@@ -117,7 +117,7 @@ public:
virtual SynchedEntityData* getEntityData();
virtual const SynchedEntityData* getEntityData() const;
__inline bool isEntityType(int type) { return getEntityTypeId() == type; }
inline bool isEntityType(int type) { return getEntityTypeId() == type; }
virtual int getEntityTypeId() const = 0;
virtual int getCreatureBaseType() const { return 0; }
virtual EntityRendererId queryEntityRenderer() { return ER_DEFAULT_RENDERER; }

4
src/world/level/chunk/DataLayer.h
View File

@@ -37,7 +37,7 @@ public:
set(x << 11 | z << 7 | y, val);
}
__inline int get(int pos) {
inline int get(int pos) {
int slot = pos >> 1;
int part = pos & 1;
@@ -47,7 +47,7 @@ public:
return (data[slot] >> 4) & 0xf;
}
}
__inline void set(int pos, int val) {
inline void set(int pos, int val) {
int slot = pos >> 1;
int part = pos & 1;

2
src/world/level/pathfinder/PathFinder.h
View File

@@ -37,7 +37,7 @@ public:
void clear() {
cache.setAll(0);
}
__inline int _index(int x, int y, int z) {
inline int _index(int x, int y, int z) {
return (x-bz) | ((z-bz) << ShiftZ) | ((y-by) << ShiftY);
}
private: