Merge pull request #2070 from mc-server/PreventNewWarnings
Fixed a lot of warnings
This commit is contained in:
commit
1e6f02437e
@ -16,8 +16,8 @@ macro (add_flags_lnk FLAGS)
|
||||
endmacro()
|
||||
|
||||
macro(add_flags_cxx FLAGS)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAGS}")
|
||||
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS}")
|
||||
#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAGS}")
|
||||
#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS}")
|
||||
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${FLAGS}")
|
||||
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${FLAGS}")
|
||||
set(CMAKE_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_COVERAGE} ${FLAGS}")
|
||||
@ -27,6 +27,16 @@ macro(add_flags_cxx FLAGS)
|
||||
endmacro()
|
||||
|
||||
|
||||
#this is a hack because we can't use cmake 2.8.10 because of travis
|
||||
macro(get_clang_version)
|
||||
execute_process(
|
||||
COMMAND "${CMAKE_CXX_COMPILER}" "--version"
|
||||
OUTPUT_VARIABLE CLANG_VERSION_OUTPUT)
|
||||
string(REGEX MATCH "version ([0-9]\\.[0-9])" x ${CLANG_VERSION_OUTPUT})
|
||||
set(CLANG_VERSION ${CMAKE_MATCH_1})
|
||||
endmacro()
|
||||
|
||||
|
||||
macro(set_flags)
|
||||
# Add coverage processing, if requested:
|
||||
if (NOT MSVC)
|
||||
@ -80,8 +90,9 @@ macro(set_flags)
|
||||
|
||||
else()
|
||||
# Let gcc / clang know that we're compiling a multi-threaded app:
|
||||
if (UNIX)
|
||||
if (${UNIX})
|
||||
add_flags_cxx("-pthread")
|
||||
add_flags_lnk("-pthread")
|
||||
endif()
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
|
||||
@ -112,6 +123,10 @@ macro(set_flags)
|
||||
add_flags_cxx("-march=native")
|
||||
endif()
|
||||
|
||||
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
get_clang_version()
|
||||
endif()
|
||||
|
||||
|
||||
# Use static CRT in MSVC builds:
|
||||
if (MSVC)
|
||||
@ -214,15 +229,6 @@ macro(enable_profile)
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
#this is a hack because we can't use cmake 2.8.10 because of travis
|
||||
macro(get_clang_version)
|
||||
execute_process(
|
||||
COMMAND "${CMAKE_CXX_COMPILER}" "--version"
|
||||
OUTPUT_VARIABLE CLANG_VERSION_OUTPUT)
|
||||
string(REGEX MATCH "version ([0-9]\\.[0-9])" x ${CLANG_VERSION_OUTPUT})
|
||||
set(CLANG_VERSION ${CMAKE_MATCH_1})
|
||||
endmacro()
|
||||
|
||||
macro(set_exe_flags)
|
||||
# Remove disabling the maximum warning level:
|
||||
# clang does not like a command line that reads -Wall -Wextra -w -Wall -Wextra and does not output any warnings
|
||||
@ -235,7 +241,7 @@ macro(set_exe_flags)
|
||||
string(REPLACE "-w" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
|
||||
string(REPLACE "-w" "" CMAKE_CXX_FLAGS_COVERAGE "${CMAKE_CXX_FLAGS_COVERAGE}")
|
||||
string(REPLACE "-w" "" CMAKE_C_FLAGS_COVERAGE "${CMAKE_C_FLAGS_COVERAGE}")
|
||||
add_flags_cxx("-Wall -Wextra -Wno-unused-parameter -Wno-error=switch")
|
||||
add_flags_cxx("-Wall -Wextra -Wno-unused-parameter")
|
||||
|
||||
# we support non-IEEE 754 fpus so can make no guarentees about error
|
||||
add_flags_cxx("-ffast-math")
|
||||
@ -246,23 +252,16 @@ macro(set_exe_flags)
|
||||
endif()
|
||||
|
||||
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
get_clang_version()
|
||||
if ("${CLANG_VERSION}" VERSION_LESS 3.0)
|
||||
message(FATAL_ERROR "MCServer requires clang version 3.0 or higher, version is ${CLANG_VERSION}")
|
||||
endif()
|
||||
# clang does not provide the __extern_always_inline macro and a part of libm depends on this when using fast-math
|
||||
add_flags_cxx("-D__extern_always_inline=inline")
|
||||
add_flags_cxx("-Werror -Weverything -Wno-c++98-compat-pedantic -Wno-string-conversion")
|
||||
add_flags_cxx("-Wno-exit-time-destructors -Wno-padded")
|
||||
add_flags_cxx("-Wno-error=sign-conversion -Wno-error=conversion -Wno-error=deprecated")
|
||||
add_flags_cxx("-Wno-error=missing-prototypes")
|
||||
add_flags_cxx("-Wno-error=shadow -Wno-error=old-style-cast -Wno-error=global-constructors")
|
||||
add_flags_cxx("-Wno-error=float-equal")
|
||||
add_flags_cxx("-Wno-weak-vtables -Wno-switch-enum")
|
||||
add_flags_cxx("-Weverything -Werror -Wno-c++98-compat-pedantic -Wno-string-conversion")
|
||||
add_flags_cxx("-Wno-exit-time-destructors -Wno-padded -Wno-weak-vtables")
|
||||
if ("${CLANG_VERSION}" VERSION_GREATER 3.0)
|
||||
# flags that are not present in 3.0
|
||||
add_flags_cxx("-Wno-error=covered-switch-default -Wno-error=missing-variable-declarations")
|
||||
add_flags_cxx("-Wno-implicit-fallthrough -Wno-error=extra-semi")
|
||||
add_flags_cxx("-Wno-implicit-fallthrough")
|
||||
endif()
|
||||
if ("${CLANG_VERSION}" VERSION_GREATER 3.1)
|
||||
# flags introduced in 3.2
|
||||
@ -276,3 +275,21 @@ macro(set_exe_flags)
|
||||
endif()
|
||||
|
||||
endmacro()
|
||||
|
||||
# if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
# foreach(FILENAME ${ARGN})
|
||||
# message("downgrade_warnings for ${FILENAME}")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=conversion")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=missing-prototypes -Wno-error=deprecated")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=shadow -Wno-error=old-style-cast -Wno-error=switch-enum -Wno-error=switch")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=float-equal -Wno-error=global-constructors")
|
||||
|
||||
# if ("${CLANG_VERSION}" VERSION_GREATER 3.0)
|
||||
# # flags that are not present in 3.0
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=covered-switch-default ")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-implicit-fallthrough -Wno-error=extra-semi")
|
||||
# set_source_files_properties(${FILENAME} PROPERTIES COMPILE_FLAGS "-Wno-error=missing-variable-declarations")
|
||||
# endif()
|
||||
# endforeach()
|
||||
# endif()
|
||||
|
||||
|
@ -11,8 +11,13 @@ set_flags()
|
||||
set_lib_flags()
|
||||
enable_profile()
|
||||
|
||||
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
add_flags_cxx("-Wno-error=sign-conversion -Wno-error=conversion -Wno-error=shorten-64-to-32")
|
||||
add_flags_cxx("-Wno-error=old-style-cast")
|
||||
if ("${CLANG_VERSION}" VERSION_GREATER 3.5)
|
||||
add_flags_cxx("-Wno-error=keyword-macro")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Set include paths to the used libraries:
|
||||
include_directories("../../lib")
|
||||
|
@ -14,7 +14,13 @@ include_directories("../../lib")
|
||||
include_directories("../../lib/polarssl/include")
|
||||
include_directories("../../src")
|
||||
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
add_flags_cxx("-Wno-error=sign-conversion -Wno-error=conversion -Wno-error=shorten-64-to-32")
|
||||
add_flags_cxx("-Wno-error=old-style-cast")
|
||||
if ("${CLANG_VERSION}" VERSION_GREATER 3.5)
|
||||
add_flags_cxx("-Wno-error=keyword-macro")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
function(flatten_files arg1)
|
||||
set(res "")
|
||||
|
@ -39,8 +39,8 @@ class cListAllocationPool : public cAllocationPool<T>
|
||||
{
|
||||
public:
|
||||
|
||||
cListAllocationPool(std::auto_ptr<typename cAllocationPool<T>::cStarvationCallbacks> a_Callbacks) :
|
||||
m_Callbacks(a_Callbacks)
|
||||
cListAllocationPool(std::unique_ptr<typename cAllocationPool<T>::cStarvationCallbacks> a_Callbacks) :
|
||||
m_Callbacks(std::move(a_Callbacks))
|
||||
{
|
||||
for (size_t i = 0; i < NumElementsInReserve; i++)
|
||||
{
|
||||
@ -105,7 +105,7 @@ class cListAllocationPool : public cAllocationPool<T>
|
||||
|
||||
private:
|
||||
std::list<void *> m_FreeList;
|
||||
std::auto_ptr<typename cAllocationPool<T>::cStarvationCallbacks> m_Callbacks;
|
||||
std::unique_ptr<typename cAllocationPool<T>::cStarvationCallbacks> m_Callbacks;
|
||||
};
|
||||
|
||||
|
||||
|
@ -101,7 +101,7 @@ local function OutputLuaStateHelpers(a_Package)
|
||||
f:write("void Push(" .. item.name .. " * a_Value);\n")
|
||||
end
|
||||
for _, item in ipairs(types) do
|
||||
f:write("void GetStackValue(int a_StackPos, Ptr" .. item.lname .. " & a_ReturnedVal);\n")
|
||||
f:write("bool GetStackValue(int a_StackPos, Ptr" .. item.lname .. " & a_ReturnedVal);\n")
|
||||
end
|
||||
f:write("\n\n\n\n\n")
|
||||
f:close()
|
||||
@ -125,15 +125,17 @@ local function OutputLuaStateHelpers(a_Package)
|
||||
end
|
||||
end
|
||||
for _, item in ipairs(types) do
|
||||
f:write("void cLuaState::GetStackValue(int a_StackPos, Ptr" .. item.lname .. " & a_ReturnedVal)\n{\n\tASSERT(IsValid());\n")
|
||||
f:write("bool cLuaState::GetStackValue(int a_StackPos, Ptr" .. item.lname .. " & a_ReturnedVal)\n{\n\tASSERT(IsValid());\n")
|
||||
f:write("\tif (lua_isnil(m_LuaState, a_StackPos))\n\t{\n")
|
||||
f:write("\t a_ReturnedVal = nullptr;\n")
|
||||
f:write("\t return;\n\t}\n")
|
||||
f:write("\t\ta_ReturnedVal = nullptr;\n")
|
||||
f:write("\t\treturn false;\n\t}\n")
|
||||
f:write("\ttolua_Error err;\n")
|
||||
f:write("\tif (tolua_isusertype(m_LuaState, a_StackPos, \"" .. item.name .. "\", false, &err))\n")
|
||||
f:write("\t{\n")
|
||||
f:write("\t a_ReturnedVal = *(reinterpret_cast<" .. item.name .. " **>(lua_touserdata(m_LuaState, a_StackPos)));\n")
|
||||
f:write("\t\ta_ReturnedVal = *(reinterpret_cast<" .. item.name .. " **>(lua_touserdata(m_LuaState, a_StackPos)));\n")
|
||||
f:write("\t\treturn true;\n");
|
||||
f:write("\t}\n")
|
||||
f:write("\treturn false;\n")
|
||||
f:write("}\n\n\n\n\n\n")
|
||||
end
|
||||
f:close()
|
||||
|
@ -145,6 +145,15 @@ set_source_files_properties(${BINDING_OUTPUTS} PROPERTIES GENERATED TRUE)
|
||||
|
||||
set_source_files_properties(${CMAKE_SOURCE_DIR}/src/Bindings/Bindings.cpp PROPERTIES COMPILE_FLAGS -Wno-error)
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(DeprecatedBindings.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(LuaState.cpp COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(LuaWindow.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum")
|
||||
set_source_files_properties(ManualBindings.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(ManualBindings_World.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(PluginLua.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
endif()
|
||||
|
||||
if(NOT MSVC)
|
||||
add_library(Bindings ${SRCS} ${HDRS})
|
||||
|
||||
|
@ -41,7 +41,7 @@ bool cLuaChunkStay::AddChunks(int a_ChunkCoordTableStackPos)
|
||||
|
||||
// Add each set of coords:
|
||||
int NumChunks = luaL_getn(L, a_ChunkCoordTableStackPos);
|
||||
m_Chunks.reserve((size_t)NumChunks);
|
||||
m_Chunks.reserve(static_cast<size_t>(NumChunks));
|
||||
for (int idx = 1; idx <= NumChunks; idx++)
|
||||
{
|
||||
// Push the idx-th element of the array onto stack top, check that it's a table:
|
||||
@ -133,7 +133,7 @@ void cLuaChunkStay::OnChunkAvailable(int a_ChunkX, int a_ChunkZ)
|
||||
if (m_OnChunkAvailable.IsValid())
|
||||
{
|
||||
cPluginLua::cOperation Op(m_Plugin);
|
||||
Op().Call((int)m_OnChunkAvailable, a_ChunkX, a_ChunkZ);
|
||||
Op().Call(static_cast<int>(m_OnChunkAvailable), a_ChunkX, a_ChunkZ);
|
||||
}
|
||||
}
|
||||
|
||||
@ -147,7 +147,7 @@ bool cLuaChunkStay::OnAllChunksAvailable(void)
|
||||
{
|
||||
// Call the callback:
|
||||
cPluginLua::cOperation Op(m_Plugin);
|
||||
Op().Call((int)m_OnAllChunksAvailable);
|
||||
Op().Call(static_cast<int>(m_OnAllChunksAvailable));
|
||||
|
||||
// Remove the callback references - they won't be needed anymore
|
||||
m_OnChunkAvailable.UnRef();
|
||||
|
@ -701,108 +701,95 @@ void cLuaState::PushUserType(void * a_Object, const char * a_Type)
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, AString & a_Value)
|
||||
{
|
||||
size_t len = 0;
|
||||
const char * data = lua_tolstring(m_LuaState, a_StackPos, &len);
|
||||
if (data != nullptr)
|
||||
{
|
||||
a_Value.assign(data, len);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, BLOCKTYPE & a_ReturnedVal)
|
||||
{
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
a_ReturnedVal = static_cast<BLOCKTYPE>(tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, bool & a_ReturnedVal)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, bool & a_ReturnedVal)
|
||||
{
|
||||
a_ReturnedVal = (tolua_toboolean(m_LuaState, a_StackPos, a_ReturnedVal ? 1 : 0) > 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result)
|
||||
{
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
a_Result = static_cast<cPluginManager::CommandResult>(static_cast<int>((tolua_tonumber(m_LuaState, a_StackPos, a_Result))));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, cRef & a_Ref)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, cRef & a_Ref)
|
||||
{
|
||||
a_Ref.RefStack(*this, a_StackPos);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, double & a_ReturnedVal)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, double & a_ReturnedVal)
|
||||
{
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
a_ReturnedVal = tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, float & a_ReturnedVal)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, float & a_ReturnedVal)
|
||||
{
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
a_ReturnedVal = static_cast<float>(tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal));
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, eWeather & a_ReturnedVal)
|
||||
bool cLuaState::GetStackValue(int a_StackPos, eWeather & a_ReturnedVal)
|
||||
{
|
||||
if (!lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
return;
|
||||
return false;
|
||||
}
|
||||
a_ReturnedVal = static_cast<eWeather>(Clamp(
|
||||
static_cast<int>(tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal)),
|
||||
static_cast<int>(wSunny), static_cast<int>(wThunderstorm))
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cLuaState::GetStackValue(int a_StackPos, int & a_ReturnedVal)
|
||||
{
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
a_ReturnedVal = static_cast<int>(tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
|
@ -187,16 +187,37 @@ public:
|
||||
void Push(cLuaUDPEndpoint * a_UDPEndpoint);
|
||||
|
||||
// GetStackValue() retrieves the value at a_StackPos, if it is a valid type. If not, a_Value is unchanged.
|
||||
// Returns whether value was changed
|
||||
// Enum values are clamped to their allowed range.
|
||||
void GetStackValue(int a_StackPos, AString & a_Value);
|
||||
void GetStackValue(int a_StackPos, BLOCKTYPE & a_Value);
|
||||
void GetStackValue(int a_StackPos, bool & a_Value);
|
||||
void GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result);
|
||||
void GetStackValue(int a_StackPos, cRef & a_Ref);
|
||||
void GetStackValue(int a_StackPos, double & a_Value);
|
||||
void GetStackValue(int a_StackPos, eWeather & a_Value);
|
||||
void GetStackValue(int a_StackPos, float & a_ReturnedVal);
|
||||
void GetStackValue(int a_StackPos, int & a_Value);
|
||||
bool GetStackValue(int a_StackPos, AString & a_Value);
|
||||
bool GetStackValue(int a_StackPos, bool & a_Value);
|
||||
bool GetStackValue(int a_StackPos, cPluginManager::CommandResult & a_Result);
|
||||
bool GetStackValue(int a_StackPos, cRef & a_Ref);
|
||||
bool GetStackValue(int a_StackPos, double & a_Value);
|
||||
bool GetStackValue(int a_StackPos, eWeather & a_Value);
|
||||
bool GetStackValue(int a_StackPos, float & a_ReturnedVal);
|
||||
|
||||
// template to catch all of the various c++ integral types without overload conflicts
|
||||
template <class T>
|
||||
bool GetStackValue(int a_StackPos, T & a_ReturnedVal, typename std::enable_if<std::is_integral<T>::value>::type * unused = nullptr)
|
||||
{
|
||||
UNUSED(unused);
|
||||
if (lua_isnumber(m_LuaState, a_StackPos))
|
||||
{
|
||||
lua_Number Val = tolua_tonumber(m_LuaState, a_StackPos, a_ReturnedVal);
|
||||
if (Val > std::numeric_limits<T>::max())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (Val < std::numeric_limits<T>::min())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
a_ReturnedVal = static_cast<T>(Val);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Include the auto-generated Push and GetStackValue() functions:
|
||||
#include "LuaState_Declaration.inc"
|
||||
@ -218,10 +239,13 @@ public:
|
||||
|
||||
/** Retrieves a list of values from the Lua stack, starting at the specified index. */
|
||||
template <typename T, typename... Args>
|
||||
inline void GetStackValues(int a_StartStackPos, T & a_Ret, Args &&... args)
|
||||
inline bool GetStackValues(int a_StartStackPos, T & a_Ret, Args &&... args)
|
||||
{
|
||||
GetStackValue(a_StartStackPos, a_Ret);
|
||||
GetStackValues(a_StartStackPos + 1, args...);
|
||||
if (!GetStackValue(a_StartStackPos, a_Ret))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return GetStackValues(a_StartStackPos + 1, args...);
|
||||
}
|
||||
|
||||
/** Returns true if the specified parameters on the stack are of the specified usertable type; also logs warning if not. Used for static functions */
|
||||
@ -349,9 +373,9 @@ protected:
|
||||
/** Variadic template terminator: If there are no more values to get, bail out.
|
||||
This function is not available in the public API, because it's an error to request no values directly; only internal functions can do that.
|
||||
If you get a compile error saying this function is not accessible, check your calling code, you aren't reading any stack values. */
|
||||
void GetStackValues(int a_StartingStackPos)
|
||||
bool GetStackValues(int a_StartingStackPos)
|
||||
{
|
||||
// Do nothing
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Pushes the function of the specified name onto the stack.
|
||||
@ -369,7 +393,7 @@ protected:
|
||||
*/
|
||||
bool PushFunction(const cRef & a_FnRef)
|
||||
{
|
||||
return PushFunction((int)a_FnRef);
|
||||
return PushFunction(static_cast<int>(a_FnRef));
|
||||
}
|
||||
|
||||
/** Pushes a function that is stored in a referenced table by name
|
||||
|
@ -158,7 +158,7 @@ static int tolua_UncompressStringZLIB(lua_State * tolua_S)
|
||||
|
||||
// Get the params:
|
||||
AString ToUncompress;
|
||||
int UncompressedSize;
|
||||
size_t UncompressedSize;
|
||||
S.GetStackValues(1, ToUncompress, UncompressedSize);
|
||||
|
||||
// Compress the string:
|
||||
@ -1801,7 +1801,7 @@ static int tolua_cMojangAPI_GetUUIDsFromPlayerNames(lua_State * L)
|
||||
// Convert the input table into AStringVector:
|
||||
AStringVector PlayerNames;
|
||||
int NumNames = luaL_getn(L, 2);
|
||||
PlayerNames.reserve(NumNames);
|
||||
PlayerNames.reserve(static_cast<size_t>(NumNames));
|
||||
for (int i = 1; i <= NumNames; i++)
|
||||
{
|
||||
lua_rawgeti(L, 2, i);
|
||||
|
@ -199,7 +199,7 @@ public:
|
||||
|
||||
// Get parameters:
|
||||
Ty1 * Self = nullptr;
|
||||
int ItemID;
|
||||
UInt32 ItemID;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, ItemID, FnRef);
|
||||
if (Self == nullptr)
|
||||
|
@ -101,13 +101,12 @@ static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
|
||||
}
|
||||
|
||||
// Read the params:
|
||||
int Port;
|
||||
S.GetStackValues(2, Port);
|
||||
UInt16 Port;
|
||||
|
||||
// Check validity:
|
||||
if ((Port < 0) || (Port > 65535))
|
||||
if (!S.GetStackValues(2, Port))
|
||||
{
|
||||
LOGWARNING("cNetwork:CreateUDPEndpoint() called with invalid port (%d), failing the request.", Port);
|
||||
LOGWARNING("cNetwork:CreateUDPEndpoint() called with invalid port, failing the request.");
|
||||
S.Push(false);
|
||||
return 1;
|
||||
}
|
||||
|
@ -50,7 +50,7 @@ static int tolua_cWorld_BroadcastParticleEffect(lua_State * tolua_S)
|
||||
std::array<int, 2> data;
|
||||
for (int i = 0; (i < 2) && L.IsParamNumber(11 + i); i++)
|
||||
{
|
||||
L.GetStackValue(11 + i, data[i]);
|
||||
L.GetStackValue(11 + i, data[static_cast<size_t>(i)]);
|
||||
}
|
||||
|
||||
World->GetBroadcaster().BroadcastParticleEffect(Name, Vector3f(PosX, PosY, PosZ), Vector3f(OffX, OffY, OffZ), ParticleData, ParticleAmmount, ExcludeClient);
|
||||
|
@ -629,11 +629,6 @@ bool cPluginLua::OnExploded(cWorld & a_World, double a_ExplosionSize, bool a_Can
|
||||
case esWitherSkullBlue: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
|
||||
case esWitherBirth: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
|
||||
case esPlugin: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res); break;
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unhandled ExplosionSource");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (res)
|
||||
{
|
||||
@ -670,11 +665,6 @@ bool cPluginLua::OnExploding(cWorld & a_World, double & a_ExplosionSize, bool &
|
||||
case esWitherSkullBlue: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
|
||||
case esWitherBirth: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
|
||||
case esPlugin: m_LuaState.Call((int)(**itr), &a_World, a_ExplosionSize, a_CanCauseFire, a_X, a_Y, a_Z, a_Source, a_SourceData, cLuaState::Return, res, a_CanCauseFire, a_ExplosionSize); break;
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unhandled ExplosionSource");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (res)
|
||||
{
|
||||
|
@ -98,11 +98,11 @@ EMCSBiome StringToBiome(const AString & a_BiomeString)
|
||||
{
|
||||
if ((res >= biFirstBiome) && (res < biNumBiomes))
|
||||
{
|
||||
return (EMCSBiome)res;
|
||||
return static_cast<EMCSBiome>(res);
|
||||
}
|
||||
else if ((res >= biFirstVariantBiome) && (res < biNumVariantBiomes))
|
||||
{
|
||||
return (EMCSBiome)res;
|
||||
return static_cast<EMCSBiome>(res);
|
||||
}
|
||||
// It was an invalid number
|
||||
return biInvalidBiome;
|
||||
|
@ -60,7 +60,7 @@ void InternalMergeBlocks(
|
||||
else
|
||||
{
|
||||
NIBBLETYPE FakeDestMeta = 0;
|
||||
Combinator(a_DstTypes[DstIdx], a_SrcTypes[SrcIdx], FakeDestMeta, (NIBBLETYPE)0);
|
||||
Combinator(a_DstTypes[DstIdx], a_SrcTypes[SrcIdx], FakeDestMeta, static_cast<NIBBLETYPE>(0));
|
||||
}
|
||||
++DstIdx;
|
||||
++SrcIdx;
|
||||
@ -620,7 +620,7 @@ void cBlockArea::DumpToRawFile(const AString & a_FileName)
|
||||
f.Write(&SizeX, 4);
|
||||
f.Write(&SizeY, 4);
|
||||
f.Write(&SizeZ, 4);
|
||||
unsigned char DataTypes = (unsigned char)GetDataTypes();
|
||||
unsigned char DataTypes = static_cast<unsigned char>(GetDataTypes());
|
||||
f.Write(&DataTypes, 1);
|
||||
size_t NumBlocks = GetBlockCount();
|
||||
if (HasBlockTypes())
|
||||
@ -2157,7 +2157,7 @@ void cBlockArea::ExpandBlockTypes(int a_SubMinX, int a_AddMaxX, int a_SubMinY, i
|
||||
int NewSizeX = m_Size.x + a_SubMinX + a_AddMaxX;
|
||||
int NewSizeY = m_Size.y + a_SubMinY + a_AddMaxY;
|
||||
int NewSizeZ = m_Size.z + a_SubMinZ + a_AddMaxZ;
|
||||
size_t BlockCount = (size_t)(NewSizeX * NewSizeY * NewSizeZ);
|
||||
size_t BlockCount = static_cast<size_t>(NewSizeX * NewSizeY * NewSizeZ);
|
||||
BLOCKTYPE * NewBlockTypes = new BLOCKTYPE[BlockCount];
|
||||
memset(NewBlockTypes, 0, BlockCount * sizeof(BLOCKTYPE));
|
||||
int OldIndex = 0;
|
||||
@ -2187,7 +2187,7 @@ void cBlockArea::ExpandNibbles(NIBBLEARRAY & a_Array, int a_SubMinX, int a_AddMa
|
||||
int NewSizeX = m_Size.x + a_SubMinX + a_AddMaxX;
|
||||
int NewSizeY = m_Size.y + a_SubMinY + a_AddMaxY;
|
||||
int NewSizeZ = m_Size.z + a_SubMinZ + a_AddMaxZ;
|
||||
size_t BlockCount = (size_t)(NewSizeX * NewSizeY * NewSizeZ);
|
||||
size_t BlockCount = static_cast<size_t>(NewSizeX * NewSizeY * NewSizeZ);
|
||||
NIBBLETYPE * NewNibbles = new NIBBLETYPE[BlockCount];
|
||||
memset(NewNibbles, 0, BlockCount * sizeof(NIBBLETYPE));
|
||||
int OldIndex = 0;
|
||||
|
@ -321,7 +321,7 @@ public:
|
||||
NIBBLETYPE * GetBlockMetas (void) const { return m_BlockMetas; } // NOTE: one byte per block!
|
||||
NIBBLETYPE * GetBlockLight (void) const { return m_BlockLight; } // NOTE: one byte per block!
|
||||
NIBBLETYPE * GetBlockSkyLight(void) const { return m_BlockSkyLight; } // NOTE: one byte per block!
|
||||
size_t GetBlockCount(void) const { return (size_t)(m_Size.x * m_Size.y * m_Size.z); }
|
||||
size_t GetBlockCount(void) const { return static_cast<size_t>(m_Size.x * m_Size.y * m_Size.z); }
|
||||
int MakeIndex(int a_RelX, int a_RelY, int a_RelZ) const;
|
||||
|
||||
protected:
|
||||
|
@ -77,7 +77,7 @@ bool cBeaconEntity::IsValidEffect(cEntityEffect::eType a_Effect, char a_BeaconLe
|
||||
|
||||
default:
|
||||
{
|
||||
LOGD("%s: Invalid beacon effect: %d", __FUNCTION__, (int)a_Effect);
|
||||
LOGD("%s: Invalid beacon effect: %d", __FUNCTION__, static_cast<int>(a_Effect));
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -228,9 +228,9 @@ void cBeaconEntity::GiveEffects(void)
|
||||
virtual bool Item(cPlayer * a_Player)
|
||||
{
|
||||
Vector3d PlayerPosition = Vector3d(a_Player->GetPosition());
|
||||
if (PlayerPosition.y > (double)m_PosY)
|
||||
if (PlayerPosition.y > static_cast<double>(m_PosY))
|
||||
{
|
||||
PlayerPosition.y = (double)m_PosY;
|
||||
PlayerPosition.y = static_cast<double>(m_PosY);
|
||||
}
|
||||
|
||||
// TODO: Vanilla minecraft uses an AABB check instead of a radius one
|
||||
|
@ -41,6 +41,11 @@ SET (HDRS
|
||||
NoteEntity.h
|
||||
SignEntity.h)
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(BeaconEntity.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=switch-enum")
|
||||
set_source_files_properties(NoteEntity.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=sign-conversion")
|
||||
endif()
|
||||
|
||||
if(NOT MSVC)
|
||||
add_library(BlockEntities ${SRCS} ${HDRS})
|
||||
endif()
|
||||
|
@ -145,9 +145,9 @@ void cMobSpawnerEntity::SpawnEntity(void)
|
||||
break;
|
||||
}
|
||||
|
||||
int RelX = (int) (m_RelX + (double)(Random.NextFloat() - Random.NextFloat()) * 4.0);
|
||||
int RelX = static_cast<int>(m_RelX + static_cast<double>(Random.NextFloat() - Random.NextFloat()) * 4.0);
|
||||
int RelY = m_RelY + Random.NextInt(3) - 1;
|
||||
int RelZ = (int) (m_RelZ + (double)(Random.NextFloat() - Random.NextFloat()) * 4.0);
|
||||
int RelZ = static_cast<int>(m_RelZ + static_cast<double>(Random.NextFloat() - Random.NextFloat()) * 4.0);
|
||||
|
||||
cChunk * Chunk = a_Chunk->GetRelNeighborChunkAdjustCoords(RelX, RelZ);
|
||||
if ((Chunk == nullptr) || !Chunk->IsValid())
|
||||
@ -172,7 +172,13 @@ void cMobSpawnerEntity::SpawnEntity(void)
|
||||
if (Chunk->GetWorld()->SpawnMobFinalize(Monster) != cEntity::INVALID_ID)
|
||||
{
|
||||
EntitiesSpawned = true;
|
||||
Chunk->BroadcastSoundParticleEffect(2004, (int)(PosX * 8.0), (int)(RelY * 8.0), (int)(PosZ * 8.0), 0);
|
||||
Chunk->BroadcastSoundParticleEffect(
|
||||
2004,
|
||||
static_cast<int>(PosX * 8.0),
|
||||
static_cast<int>(RelY * 8.0),
|
||||
static_cast<int>(PosZ * 8.0),
|
||||
0
|
||||
);
|
||||
m_NearbyEntitiesNum++;
|
||||
}
|
||||
}
|
||||
@ -246,9 +252,9 @@ int cMobSpawnerEntity::GetNearbyMonsterNum(eMonsterType a_EntityType)
|
||||
class cCallback : public cChunkDataCallback
|
||||
{
|
||||
public:
|
||||
cCallback(Vector3d a_SpawnerPos, eMonsterType a_EntityType, int & a_NumEntities) :
|
||||
cCallback(Vector3d a_SpawnerPos, eMonsterType a_CallbackEntityType, int & a_NumEntities) :
|
||||
m_SpawnerPos(a_SpawnerPos),
|
||||
m_EntityType(a_EntityType),
|
||||
m_EntityType(a_CallbackEntityType),
|
||||
m_NumEntities(a_NumEntities)
|
||||
{
|
||||
}
|
||||
@ -260,7 +266,7 @@ int cMobSpawnerEntity::GetNearbyMonsterNum(eMonsterType a_EntityType)
|
||||
return;
|
||||
}
|
||||
|
||||
cMonster * Mob = (cMonster *)a_Entity;
|
||||
cMonster * Mob = static_cast<cMonster *>(a_Entity);
|
||||
if (Mob->GetMobType() != m_EntityType)
|
||||
{
|
||||
return;
|
||||
|
@ -90,8 +90,15 @@ void cNoteEntity::MakeSound(void)
|
||||
m_World->BroadcastBlockAction(m_PosX, m_PosY, m_PosZ, instrument, m_Pitch, E_BLOCK_NOTE_BLOCK);
|
||||
|
||||
// TODO: instead of calculating the power function over and over, make a precalculated table - there's only 24 pitches after all
|
||||
float calcPitch = pow(2.0f, ((float)m_Pitch - 12.0f) / 12.0f);
|
||||
m_World->BroadcastSoundEffect(sampleName, (double)m_PosX, (double)m_PosY, (double)m_PosZ, 3.0f, calcPitch);
|
||||
float calcPitch = pow(2.0f, static_cast<float>(m_Pitch - 12.0f) / 12.0f);
|
||||
m_World->BroadcastSoundEffect(
|
||||
sampleName,
|
||||
static_cast<double>(m_PosX),
|
||||
static_cast<double>(m_PosY),
|
||||
static_cast<double>(m_PosZ),
|
||||
3.0f,
|
||||
calcPitch
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
|
@ -96,8 +96,7 @@ public:
|
||||
else
|
||||
{
|
||||
// Not a resolvable string, try pure numbers: "45:6", "45^6" etc.
|
||||
a_Item.m_ItemType = (short)atoi(Split[0].c_str());
|
||||
if ((a_Item.m_ItemType == 0) && (Split[0] != "0"))
|
||||
if (!StringToInteger(Split[0], a_Item.m_ItemType))
|
||||
{
|
||||
// Parsing the number failed
|
||||
return false;
|
||||
@ -112,8 +111,7 @@ public:
|
||||
return true;
|
||||
}
|
||||
|
||||
a_Item.m_ItemDamage = (short)atoi(Split[1].c_str());
|
||||
if ((a_Item.m_ItemDamage == 0) && (Split[1] != "0"))
|
||||
if (!StringToInteger(Split[1], a_Item.m_ItemDamage))
|
||||
{
|
||||
// Parsing the number failed
|
||||
return false;
|
||||
@ -175,8 +173,16 @@ protected:
|
||||
{
|
||||
return;
|
||||
}
|
||||
short ItemType = (short)atoi(Split[0].c_str());
|
||||
short ItemDamage = (Split.size() > 1) ? (short)atoi(Split[1].c_str()) : -1;
|
||||
short ItemType;
|
||||
if (!StringToInteger(Split[0], ItemType))
|
||||
{
|
||||
ASSERT(!"Invalid item type");
|
||||
}
|
||||
short ItemDamage = -1;
|
||||
if (Split.size() > 1 && !StringToInteger(Split[1], ItemDamage))
|
||||
{
|
||||
ASSERT(!"Invalid item damage");
|
||||
}
|
||||
m_Map[a_Name] = std::make_pair(ItemType, ItemDamage);
|
||||
}
|
||||
} ;
|
||||
@ -288,11 +294,11 @@ AString ItemToFullString(const cItem & a_Item)
|
||||
eDimension StringToDimension(const AString & a_DimensionString)
|
||||
{
|
||||
// First try decoding as a number
|
||||
int res = atoi(a_DimensionString.c_str());
|
||||
if ((res != 0) || (a_DimensionString == "0"))
|
||||
int res;
|
||||
if (!StringToInteger(a_DimensionString, res))
|
||||
{
|
||||
// It was a valid number
|
||||
return (eDimension)res;
|
||||
return static_cast<eDimension>(res);
|
||||
}
|
||||
|
||||
// Decode using a built-in map:
|
||||
@ -350,7 +356,7 @@ AString DimensionToString(eDimension a_Dimension)
|
||||
} // for i - DimensionMap[]
|
||||
|
||||
// Not found
|
||||
LOGWARNING("Unknown dimension: \"%i\". Setting to Overworld", (int)a_Dimension);
|
||||
LOGWARNING("Unknown dimension: \"%i\". Setting to Overworld", static_cast<int>(a_Dimension));
|
||||
return "Overworld";
|
||||
}
|
||||
|
||||
@ -386,7 +392,7 @@ AString DamageTypeToString(eDamageType a_DamageType)
|
||||
|
||||
// Unknown damage type:
|
||||
ASSERT(!"Unknown DamageType");
|
||||
return Printf("dtUnknown_%d", (int)a_DamageType);
|
||||
return Printf("dtUnknown_%d", static_cast<int>(a_DamageType));
|
||||
}
|
||||
|
||||
|
||||
@ -397,11 +403,11 @@ AString DamageTypeToString(eDamageType a_DamageType)
|
||||
eDamageType StringToDamageType(const AString & a_DamageTypeString)
|
||||
{
|
||||
// First try decoding as a number:
|
||||
int res = atoi(a_DamageTypeString.c_str());
|
||||
if ((res != 0) || (a_DamageTypeString == "0"))
|
||||
int res;
|
||||
if (!StringToInteger(a_DamageTypeString, res))
|
||||
{
|
||||
// It was a valid number
|
||||
return (eDamageType)res;
|
||||
return static_cast<eDamageType>(res);
|
||||
}
|
||||
|
||||
// Decode using a built-in map:
|
||||
@ -462,7 +468,7 @@ eDamageType StringToDamageType(const AString & a_DamageTypeString)
|
||||
} // for i - DamageTypeMap[]
|
||||
|
||||
// Not found:
|
||||
return (eDamageType)-1;
|
||||
return static_cast<eDamageType>(-1);
|
||||
}
|
||||
|
||||
|
||||
|
@ -19,7 +19,7 @@ void cBlockInfo::Initialize(cBlockInfoArray & a_Info)
|
||||
{
|
||||
if (a_Info[i].m_Handler == nullptr)
|
||||
{
|
||||
a_Info[i].m_Handler = cBlockHandler::CreateBlockHandler((BLOCKTYPE) i);
|
||||
a_Info[i].m_Handler = cBlockHandler::CreateBlockHandler(static_cast<BLOCKTYPE>(i));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -46,10 +46,10 @@ public:
|
||||
|
||||
switch (Direction)
|
||||
{
|
||||
case 0: a_BlockMeta = 0x2 | Meta << 2; break;
|
||||
case 1: a_BlockMeta = 0x3 | Meta << 2; break;
|
||||
case 2: a_BlockMeta = 0x0 | Meta << 2; break;
|
||||
case 3: a_BlockMeta = 0x1 | Meta << 2; break;
|
||||
case 0: a_BlockMeta = static_cast<NIBBLETYPE>(0x2 | Meta << 2); break;
|
||||
case 1: a_BlockMeta = static_cast<NIBBLETYPE>(0x3 | Meta << 2); break;
|
||||
case 2: a_BlockMeta = static_cast<NIBBLETYPE>(0x0 | Meta << 2); break;
|
||||
case 3: a_BlockMeta = static_cast<NIBBLETYPE>(0x1 | Meta << 2); break;
|
||||
default:
|
||||
{
|
||||
return false;
|
||||
|
@ -53,7 +53,7 @@ public:
|
||||
|
||||
a_Rotation = (a_Rotation / 360) * 4;
|
||||
|
||||
return ((char)a_Rotation + 2) % 4;
|
||||
return (static_cast<NIBBLETYPE>(a_Rotation + 2)) % 4;
|
||||
}
|
||||
|
||||
static Vector3i MetaDataToDirection(NIBBLETYPE a_MetaData)
|
||||
|
@ -67,7 +67,7 @@ public:
|
||||
case BLOCK_FACE_XM: return 0x2;
|
||||
case BLOCK_FACE_XP: return 0x1;
|
||||
case BLOCK_FACE_YM: return 0x0;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
ASSERT(!"Unhandled block face!");
|
||||
return 0x0;
|
||||
|
@ -81,7 +81,9 @@ public:
|
||||
case BLOCK_FACE_XM: return 3;
|
||||
case BLOCK_FACE_XP: return 1;
|
||||
case BLOCK_FACE_ZP: return 2;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
ASSERT(!"Unknown face");
|
||||
return 0;
|
||||
|
@ -245,10 +245,10 @@ public:
|
||||
if (a_BlockX > 0)
|
||||
{
|
||||
NIBBLETYPE DownMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY - 1, a_BlockZ);
|
||||
return (NIBBLETYPE) ((DownMeta & 0x07) | 0x08 | (Meta << 4));
|
||||
return static_cast<NIBBLETYPE>((DownMeta & 0x07) | 0x08 | (Meta << 4));
|
||||
}
|
||||
// This is the top part of the door at the bottommost layer of the world, there's no bottom:
|
||||
return (NIBBLETYPE) (0x08 | (Meta << 4));
|
||||
return static_cast<NIBBLETYPE>(0x08 | (Meta << 4));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -256,7 +256,7 @@ public:
|
||||
if (a_BlockY < cChunkDef::Height - 1)
|
||||
{
|
||||
NIBBLETYPE UpMeta = a_ChunkInterface.GetBlockMeta(a_BlockX, a_BlockY + 1, a_BlockZ);
|
||||
return (NIBBLETYPE) (Meta | (UpMeta << 4));
|
||||
return static_cast<NIBBLETYPE>(Meta | (UpMeta << 4));
|
||||
}
|
||||
// This is the bottom part of the door at the topmost layer of the world, there's no top:
|
||||
return Meta;
|
||||
|
@ -35,7 +35,7 @@ public:
|
||||
case BLOCK_FACE_NORTH: a_BlockMeta = E_META_HOPPER_FACING_ZP; break;
|
||||
case BLOCK_FACE_SOUTH: a_BlockMeta = E_META_HOPPER_FACING_ZM; break;
|
||||
case BLOCK_FACE_WEST: a_BlockMeta = E_META_HOPPER_FACING_XP; break;
|
||||
default: a_BlockMeta = E_META_HOPPER_UNATTACHED; break;
|
||||
case BLOCK_FACE_NONE: a_BlockMeta = E_META_HOPPER_UNATTACHED; break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -57,7 +57,12 @@ public:
|
||||
case BLOCK_FACE_ZP: return 0x3;
|
||||
case BLOCK_FACE_XM: return 0x4;
|
||||
case BLOCK_FACE_XP: return 0x5;
|
||||
default: return 0x2;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
return 0x2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -59,7 +59,7 @@ public:
|
||||
cItem(
|
||||
E_BLOCK_SAPLING,
|
||||
1,
|
||||
(m_BlockType == E_BLOCK_LEAVES) ? (a_BlockMeta & 0x03) : (4 + (a_BlockMeta & 0x01))
|
||||
(m_BlockType == E_BLOCK_LEAVES) ? (a_BlockMeta & 0x03) : static_cast<short>(4 + (a_BlockMeta & 0x01))
|
||||
)
|
||||
);
|
||||
}
|
||||
|
@ -65,7 +65,7 @@ public:
|
||||
case BLOCK_FACE_ZP: return 0x3;
|
||||
case BLOCK_FACE_ZM: return 0x4;
|
||||
case BLOCK_FACE_YM: return 0x0;
|
||||
default: return 0x6;
|
||||
case BLOCK_FACE_NONE: return 0x6;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -58,7 +58,7 @@ public:
|
||||
return 0x3; // East or west
|
||||
}
|
||||
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
ASSERT(!"Unhandled block face!");
|
||||
return a_QuartzMeta; // No idea, give a special meta (all sides the same)
|
||||
|
@ -487,7 +487,12 @@ public:
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
@ -58,7 +58,7 @@ public:
|
||||
return a_Meta | 0x4; // East or west
|
||||
}
|
||||
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
ASSERT(!"Unhandled block face!");
|
||||
return a_Meta | 0xC; // No idea, give a special meta
|
||||
|
@ -41,7 +41,7 @@ public:
|
||||
) override
|
||||
{
|
||||
a_BlockType = m_BlockType;
|
||||
NIBBLETYPE Meta = (NIBBLETYPE) a_Player->GetEquippedItem().m_ItemDamage;
|
||||
NIBBLETYPE Meta = static_cast<NIBBLETYPE>(a_Player->GetEquippedItem().m_ItemDamage);
|
||||
|
||||
// Set the correct metadata based on player equipped item (i.e. a_BlockMeta not initialised yet)
|
||||
switch (a_BlockFace)
|
||||
@ -104,7 +104,7 @@ public:
|
||||
|
||||
virtual void OnCancelRightClick(cChunkInterface & a_ChunkInterface, cWorldInterface & a_WorldInterface, cPlayer * a_Player, int a_BlockX, int a_BlockY, int a_BlockZ, eBlockFace a_BlockFace) override
|
||||
{
|
||||
if ((a_BlockFace == BLOCK_FACE_NONE) || (a_Player->GetEquippedItem().m_ItemType != (short)m_BlockType))
|
||||
if ((a_BlockFace == BLOCK_FACE_NONE) || (a_Player->GetEquippedItem().m_ItemType != static_cast<short>(m_BlockType)))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
@ -59,7 +59,7 @@ public:
|
||||
case BLOCK_FACE_WEST: return E_META_TORCH_WEST;
|
||||
case BLOCK_FACE_NORTH: return E_META_TORCH_NORTH;
|
||||
case BLOCK_FACE_SOUTH: return E_META_TORCH_SOUTH;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
ASSERT(!"Unhandled torch direction!");
|
||||
break;
|
||||
|
@ -74,7 +74,9 @@ public:
|
||||
case BLOCK_FACE_ZM: return 0x0;
|
||||
case BLOCK_FACE_XP: return 0x3;
|
||||
case BLOCK_FACE_XM: return 0x2;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
ASSERT(!"Unhandled block face!");
|
||||
return 0;
|
||||
|
@ -37,7 +37,13 @@ public:
|
||||
case BLOCK_FACE_XP: return 0x3;
|
||||
case BLOCK_FACE_ZM: return 0x2;
|
||||
case BLOCK_FACE_ZP: return 0x0;
|
||||
default: ASSERT(!"Unhandled tripwire hook direction!"); return 0x0;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
ASSERT(!"Unhandled tripwire hook direction!");
|
||||
return 0x0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -55,11 +55,13 @@ public:
|
||||
{
|
||||
switch (a_Direction)
|
||||
{
|
||||
case 0x2: return 0x2;
|
||||
case 0x3: return 0x3;
|
||||
case 0x4: return 0x4;
|
||||
case 0x5: return 0x5;
|
||||
default:
|
||||
case BLOCK_FACE_ZM: return 0x2;
|
||||
case BLOCK_FACE_ZP: return 0x3;
|
||||
case BLOCK_FACE_XM: return 0x4;
|
||||
case BLOCK_FACE_XP: return 0x5;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YP:
|
||||
case BLOCK_FACE_YM:
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
@ -95,6 +95,11 @@ SET (HDRS
|
||||
MetaRotator.h
|
||||
WorldInterface.h)
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(BlockHandler.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(BlockPiston.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
endif()
|
||||
|
||||
if(NOT MSVC)
|
||||
add_library(Blocks ${SRCS} ${HDRS})
|
||||
endif()
|
||||
|
@ -151,6 +151,38 @@ include_directories (SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/../lib/TCLAP/include")
|
||||
|
||||
configure_file("BuildInfo.h.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/BuildInfo.h")
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(BiomeDef.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum")
|
||||
set_source_files_properties(BlockArea.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion")
|
||||
set_source_files_properties(BlockID.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(BoundingBox.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors -Wno-error=float-equal")
|
||||
set_source_files_properties(ByteBuffer.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=old-style-cast -Wno-error=global-constructors")
|
||||
set_source_files_properties(Chunk.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(ChunkData.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(ChunkMap.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=shadow -Wno-error=sign-conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(ClientHandle.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=sign-conversion -Wno-error=global-constructors -Wno-error=old-style-cast")
|
||||
set_source_files_properties(CompositeChat.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors -Wno-error=missing-variable-declarations")
|
||||
set_source_files_properties(Enchantments.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(IniFile.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Inventory.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion")
|
||||
set_source_files_properties(Item.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(ItemGrid.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion")
|
||||
set_source_files_properties(LightingThread.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=sign-conversion")
|
||||
set_source_files_properties(LinearInterpolation.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(Map.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(MobProximityCounter.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=float-equal")
|
||||
set_source_files_properties(MobSpawner.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum")
|
||||
set_source_files_properties(RCONServer.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion")
|
||||
set_source_files_properties(Root.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=shadow -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Server.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(Statistics.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(StringCompression.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(StringUtils.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Tracer.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion")
|
||||
set_source_files_properties(World.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(main.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=missing-variable-declarations -Wno-error=missing-prototypes")
|
||||
endif()
|
||||
|
||||
if (NOT MSVC)
|
||||
# Bindings need to reference other folders, so they are done here instead
|
||||
# lib dependencies are not included
|
||||
|
@ -714,8 +714,8 @@ void cChunk::MoveEntityToNewChunk(cEntity * a_Entity)
|
||||
cEntity * m_Entity;
|
||||
|
||||
public:
|
||||
cMover(cEntity * a_Entity) :
|
||||
m_Entity(a_Entity)
|
||||
cMover(cEntity * a_CallbackEntity) :
|
||||
m_Entity(a_CallbackEntity)
|
||||
{}
|
||||
} Mover(a_Entity);
|
||||
|
||||
|
@ -190,7 +190,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
inline static int GetHeight(const HeightMap & a_HeightMap, int a_X, int a_Z)
|
||||
inline static HEIGHTTYPE GetHeight(const HeightMap & a_HeightMap, int a_X, int a_Z)
|
||||
{
|
||||
ASSERT((a_X >= 0) && (a_X < Width));
|
||||
ASSERT((a_Z >= 0) && (a_Z < Width));
|
||||
@ -198,7 +198,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
inline static void SetHeight(HeightMap & a_HeightMap, int a_X, int a_Z, unsigned char a_Height)
|
||||
inline static void SetHeight(HeightMap & a_HeightMap, int a_X, int a_Z, HEIGHTTYPE a_Height)
|
||||
{
|
||||
ASSERT((a_X >= 0) && (a_X < Width));
|
||||
ASSERT((a_Z >= 0) && (a_Z < Width));
|
||||
|
@ -125,10 +125,6 @@ void cChunkSender::QueueSendChunkTo(int a_ChunkX, int a_ChunkZ, eChunkPriority a
|
||||
m_SendChunksHighPriority.push_back(Chunk);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unknown chunk priority!");
|
||||
}
|
||||
}
|
||||
}
|
||||
m_evtQueue.Set();
|
||||
@ -342,7 +338,7 @@ void cChunkSender::BiomeData(const cChunkDef::BiomeMap * a_BiomeMap)
|
||||
if ((*a_BiomeMap)[i] < 255)
|
||||
{
|
||||
// Normal MC biome, copy as-is:
|
||||
m_BiomeMap[i] = (unsigned char)((*a_BiomeMap)[i]);
|
||||
m_BiomeMap[i] = static_cast<unsigned char>((*a_BiomeMap)[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -342,7 +342,11 @@ AString cCompositeChat::ExtractText(void) const
|
||||
}
|
||||
case ptUrl:
|
||||
{
|
||||
Msg.append(((cUrlPart *)(*itr))->m_Url);
|
||||
Msg.append((static_cast<cUrlPart *>(*itr))->m_Url);
|
||||
break;
|
||||
}
|
||||
case ptShowAchievement:
|
||||
{
|
||||
break;
|
||||
}
|
||||
} // switch (PartType)
|
||||
@ -419,7 +423,7 @@ AString cCompositeChat::CreateJsonString(bool a_ShouldUseChatPrefixes) const
|
||||
|
||||
case cCompositeChat::ptClientTranslated:
|
||||
{
|
||||
const cCompositeChat::cClientTranslatedPart & p = (const cCompositeChat::cClientTranslatedPart &)**itr;
|
||||
const cCompositeChat::cClientTranslatedPart & p = static_cast<const cCompositeChat::cClientTranslatedPart &>(**itr);
|
||||
Part["translate"] = p.m_Text;
|
||||
Json::Value With;
|
||||
for (AStringVector::const_iterator itrW = p.m_Parameters.begin(), endW = p.m_Parameters.end(); itrW != endW; ++itr)
|
||||
@ -436,7 +440,7 @@ AString cCompositeChat::CreateJsonString(bool a_ShouldUseChatPrefixes) const
|
||||
|
||||
case cCompositeChat::ptUrl:
|
||||
{
|
||||
const cCompositeChat::cUrlPart & p = (const cCompositeChat::cUrlPart &)**itr;
|
||||
const cCompositeChat::cUrlPart & p = static_cast<const cCompositeChat::cUrlPart &>(**itr);
|
||||
Part["text"] = p.m_Text;
|
||||
Json::Value Url;
|
||||
Url["action"] = "open_url";
|
||||
@ -449,7 +453,7 @@ AString cCompositeChat::CreateJsonString(bool a_ShouldUseChatPrefixes) const
|
||||
case cCompositeChat::ptSuggestCommand:
|
||||
case cCompositeChat::ptRunCommand:
|
||||
{
|
||||
const cCompositeChat::cCommandPart & p = (const cCompositeChat::cCommandPart &)**itr;
|
||||
const cCompositeChat::cCommandPart & p = static_cast<const cCompositeChat::cCommandPart &>(**itr);
|
||||
Part["text"] = p.m_Text;
|
||||
Json::Value Cmd;
|
||||
Cmd["action"] = (p.m_PartType == cCompositeChat::ptRunCommand) ? "run_command" : "suggest_command";
|
||||
@ -461,7 +465,7 @@ AString cCompositeChat::CreateJsonString(bool a_ShouldUseChatPrefixes) const
|
||||
|
||||
case cCompositeChat::ptShowAchievement:
|
||||
{
|
||||
const cCompositeChat::cShowAchievementPart & p = (const cCompositeChat::cShowAchievementPart &)**itr;
|
||||
const cCompositeChat::cShowAchievementPart & p = static_cast<const cCompositeChat::cShowAchievementPart &>(**itr);
|
||||
Part["translate"] = "chat.type.achievement";
|
||||
|
||||
Json::Value Ach;
|
||||
|
@ -373,7 +373,7 @@ void cCraftingRecipes::AddRecipeLine(int a_LineNum, const AString & a_RecipeLine
|
||||
AStringVector Sides = StringSplit(RecipeLine, "=");
|
||||
if (Sides.size() != 2)
|
||||
{
|
||||
LOGWARNING("crafting.txt: line %d: A single '=' was expected, got %d", a_LineNum, (int)Sides.size() - 1);
|
||||
LOGWARNING("crafting.txt: line %d: A single '=' was expected, got " SIZE_T_FMT, a_LineNum, Sides.size() - 1);
|
||||
LOGINFO("Offending line: \"%s\"", a_RecipeLine.c_str());
|
||||
return;
|
||||
}
|
||||
@ -833,7 +833,7 @@ void cCraftingRecipes::HandleFireworks(const cItem * a_CraftingGrid, cCraftingRe
|
||||
case E_ITEM_DYE:
|
||||
{
|
||||
int GridID = (itr->x + a_OffsetX) + a_GridStride * (itr->y + a_OffsetY);
|
||||
DyeColours.push_back(cFireworkItem::GetVanillaColourCodeFromDye((NIBBLETYPE)(a_CraftingGrid[GridID].m_ItemDamage & 0x0f)));
|
||||
DyeColours.push_back(cFireworkItem::GetVanillaColourCodeFromDye(static_cast<NIBBLETYPE>(a_CraftingGrid[GridID].m_ItemDamage & 0x0f)));
|
||||
break;
|
||||
}
|
||||
case E_ITEM_GUNPOWDER: break;
|
||||
|
@ -238,7 +238,12 @@ inline eBlockFace MirrorBlockFaceY(eBlockFace a_BlockFace)
|
||||
case BLOCK_FACE_XP: return BLOCK_FACE_XM;
|
||||
case BLOCK_FACE_ZM: return BLOCK_FACE_ZP;
|
||||
case BLOCK_FACE_ZP: return BLOCK_FACE_ZM;
|
||||
default: return a_BlockFace;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
return a_BlockFace;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -255,7 +260,12 @@ inline eBlockFace RotateBlockFaceCCW(eBlockFace a_BlockFace)
|
||||
case BLOCK_FACE_XP: return BLOCK_FACE_ZM;
|
||||
case BLOCK_FACE_ZM: return BLOCK_FACE_XM;
|
||||
case BLOCK_FACE_ZP: return BLOCK_FACE_XP;
|
||||
default: return a_BlockFace;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
return a_BlockFace;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -271,7 +281,12 @@ inline eBlockFace RotateBlockFaceCW(eBlockFace a_BlockFace)
|
||||
case BLOCK_FACE_XP: return BLOCK_FACE_ZP;
|
||||
case BLOCK_FACE_ZM: return BLOCK_FACE_XP;
|
||||
case BLOCK_FACE_ZP: return BLOCK_FACE_XM;
|
||||
default: return a_BlockFace;
|
||||
case BLOCK_FACE_NONE:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_YP:
|
||||
{
|
||||
return a_BlockFace;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -285,7 +300,7 @@ inline eBlockFace ReverseBlockFace(eBlockFace a_BlockFace)
|
||||
case BLOCK_FACE_YM: return BLOCK_FACE_YP;
|
||||
case BLOCK_FACE_XM: return BLOCK_FACE_XP;
|
||||
case BLOCK_FACE_ZM: return BLOCK_FACE_ZP;
|
||||
default: return a_BlockFace;
|
||||
case BLOCK_FACE_NONE: return a_BlockFace;
|
||||
}
|
||||
}
|
||||
|
||||
@ -436,7 +451,7 @@ inline void AddFaceDirection(int & a_BlockX, int & a_BlockY, int & a_BlockZ, eBl
|
||||
case BLOCK_FACE_ZP: a_BlockZ++; break;
|
||||
case BLOCK_FACE_XP: a_BlockX++; break;
|
||||
case BLOCK_FACE_XM: a_BlockX--; break;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
LOGWARNING("%s: Unknown face: %d", __FUNCTION__, a_BlockFace);
|
||||
ASSERT(!"AddFaceDirection(): Unknown face");
|
||||
@ -454,7 +469,7 @@ inline void AddFaceDirection(int & a_BlockX, int & a_BlockY, int & a_BlockZ, eBl
|
||||
case BLOCK_FACE_ZP: a_BlockZ--; break;
|
||||
case BLOCK_FACE_XP: a_BlockX--; break;
|
||||
case BLOCK_FACE_XM: a_BlockX++; break;
|
||||
default:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
LOGWARNING("%s: Unknown inv face: %d", __FUNCTION__, a_BlockFace);
|
||||
ASSERT(!"AddFaceDirection(): Unknown face");
|
||||
|
@ -69,8 +69,8 @@ void cEnchantments::AddFromString(const AString & a_StringSpec)
|
||||
LOG("%s: Failed to parse enchantment \"%s\", skipping.", __FUNCTION__, Split[0].c_str());
|
||||
continue;
|
||||
}
|
||||
int lvl = atoi(Split[1].c_str());
|
||||
if ((lvl == 0) && (Split[1] != "0"))
|
||||
unsigned int lvl;
|
||||
if (!StringToInteger(Split[1], lvl))
|
||||
{
|
||||
// Level failed to parse
|
||||
LOG("%s: Failed to parse enchantment level \"%s\", skipping.", __FUNCTION__, Split[1].c_str());
|
||||
@ -108,7 +108,7 @@ AString cEnchantments::ToString(void) const
|
||||
|
||||
|
||||
|
||||
int cEnchantments::GetLevel(int a_EnchantmentID) const
|
||||
unsigned int cEnchantments::GetLevel(int a_EnchantmentID) const
|
||||
{
|
||||
// Return the level for the specified enchantment; 0 if not stored
|
||||
cMap::const_iterator itr = m_Enchantments.find(a_EnchantmentID);
|
||||
@ -125,7 +125,7 @@ int cEnchantments::GetLevel(int a_EnchantmentID) const
|
||||
|
||||
|
||||
|
||||
void cEnchantments::SetLevel(int a_EnchantmentID, int a_Level)
|
||||
void cEnchantments::SetLevel(int a_EnchantmentID, unsigned int a_Level)
|
||||
{
|
||||
// Sets the level for the specified enchantment, adding it if not stored before or removing it if level <= 0
|
||||
if (a_Level == 0)
|
||||
@ -908,7 +908,7 @@ void cEnchantments::AddItemEnchantmentWeights(cWeightedEnchantments & a_Enchantm
|
||||
|
||||
|
||||
|
||||
void cEnchantments::AddEnchantmentWeightToVector(cWeightedEnchantments & a_Enchantments, int a_Weight, int a_EnchantmentID, int a_EnchantmentLevel)
|
||||
void cEnchantments::AddEnchantmentWeightToVector(cWeightedEnchantments & a_Enchantments, int a_Weight, int a_EnchantmentID, unsigned int a_EnchantmentLevel)
|
||||
{
|
||||
cWeightedEnchantment weightedenchantment;
|
||||
weightedenchantment.m_Weight = a_Weight;
|
||||
|
@ -92,10 +92,10 @@ public:
|
||||
AString ToString(void) const;
|
||||
|
||||
/** Returns the level for the specified enchantment; 0 if not stored */
|
||||
int GetLevel(int a_EnchantmentID) const;
|
||||
unsigned int GetLevel(int a_EnchantmentID) const;
|
||||
|
||||
/** Sets the level for the specified enchantment, adding it if not stored before or removing it if level <= 0 */
|
||||
void SetLevel(int a_EnchantmentID, int a_Level);
|
||||
void SetLevel(int a_EnchantmentID, unsigned int a_Level);
|
||||
|
||||
/** Removes all enchantments */
|
||||
void Clear(void);
|
||||
@ -115,7 +115,7 @@ public:
|
||||
static void AddItemEnchantmentWeights(cWeightedEnchantments & a_Enchantments, short a_ItemType, int a_EnchantmentLevel);
|
||||
|
||||
/** Add a enchantment with weight to the vector */
|
||||
static void AddEnchantmentWeightToVector(cWeightedEnchantments & a_Enchantments, int a_Weight, int a_EnchantmentID, int a_EnchantmentLevel);
|
||||
static void AddEnchantmentWeightToVector(cWeightedEnchantments & a_Enchantments, int a_Weight, int a_EnchantmentID, unsigned int a_EnchantmentLevel);
|
||||
|
||||
/** Remove the entire enchantment (with weight) from the vector */
|
||||
static void RemoveEnchantmentWeightFromVector(cWeightedEnchantments & a_Enchantments, int a_EnchantmentID);
|
||||
@ -145,7 +145,7 @@ public:
|
||||
|
||||
protected:
|
||||
/** Maps enchantment ID -> enchantment level */
|
||||
typedef std::map<int, int> cMap;
|
||||
typedef std::map<int, unsigned int> cMap;
|
||||
|
||||
/** Currently stored enchantments */
|
||||
cMap m_Enchantments;
|
||||
|
@ -108,7 +108,7 @@ void cArrowEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
|
||||
Damage += m_World->GetTickRandomNumber(Damage / 2 + 2);
|
||||
}
|
||||
|
||||
int PowerLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPower);
|
||||
unsigned int PowerLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPower);
|
||||
if (PowerLevel > 0)
|
||||
{
|
||||
int ExtraDamage = (int)ceil(0.25 * (PowerLevel + 1));
|
||||
@ -116,7 +116,7 @@ void cArrowEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
|
||||
}
|
||||
|
||||
// int KnockbackAmount = 1;
|
||||
int PunchLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPunch);
|
||||
unsigned int PunchLevel = m_CreatorData.m_Enchantments.GetLevel(cEnchantments::enchPunch);
|
||||
if (PunchLevel > 0)
|
||||
{
|
||||
Vector3d LookVector = GetLookVector();
|
||||
|
@ -60,6 +60,14 @@ SET (HDRS
|
||||
ThrownSnowballEntity.h
|
||||
WitherSkullEntity.h)
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(ArrowEntity.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(Entity.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=global-constructors -Wno-error=switch-enum -Wno-error=old-style-cast")
|
||||
set_source_files_properties(EntityEffect.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Floater.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Player.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=sign-conversion -Wno-error=switch-enum -Wno-error=conversion -Wno-error=old-style-cast")
|
||||
endif()
|
||||
|
||||
if(NOT MSVC)
|
||||
add_library(Entities ${SRCS} ${HDRS})
|
||||
|
||||
|
@ -22,7 +22,7 @@ cEnderCrystal::cEnderCrystal(double a_X, double a_Y, double a_Z)
|
||||
|
||||
void cEnderCrystal::SpawnOn(cClientHandle & a_ClientHandle)
|
||||
{
|
||||
a_ClientHandle.SendSpawnObject(*this, 51, 0, (Byte)GetYaw(), (Byte)GetPitch());
|
||||
a_ClientHandle.SendSpawnObject(*this, 51, 0, static_cast<Byte>(GetYaw()), static_cast<Byte>(GetPitch()));
|
||||
}
|
||||
|
||||
|
||||
|
@ -396,7 +396,7 @@ bool cEntity::DoTakeDamage(TakeDamageInfo & a_TDI)
|
||||
}
|
||||
}
|
||||
|
||||
int ThornsLevel = 0;
|
||||
unsigned int ThornsLevel = 0;
|
||||
const cItem ArmorItems[] = { GetEquippedHelmet(), GetEquippedChestplate(), GetEquippedLeggings(), GetEquippedBoots() };
|
||||
for (size_t i = 0; i < ARRAYCOUNT(ArmorItems); i++)
|
||||
{
|
||||
|
@ -205,8 +205,8 @@ public:
|
||||
double GetSpeedZ (void) const { return m_Speed.z; }
|
||||
double GetWidth (void) const { return m_Width; }
|
||||
|
||||
int GetChunkX(void) const {return (int)floor(m_Pos.x / cChunkDef::Width); }
|
||||
int GetChunkZ(void) const {return (int)floor(m_Pos.z / cChunkDef::Width); }
|
||||
int GetChunkX(void) const {return static_cast<int>(floor(m_Pos.x / cChunkDef::Width)); }
|
||||
int GetChunkZ(void) const {return static_cast<int>(floor(m_Pos.z / cChunkDef::Width)); }
|
||||
|
||||
void SetHeadYaw (double a_HeadYaw);
|
||||
void SetHeight (double a_Height);
|
||||
|
@ -56,12 +56,12 @@ void cExpOrb::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
|
||||
LOGD("Player %s picked up an ExpOrb. His reward is %i", a_ClosestPlayer->GetName().c_str(), m_Reward);
|
||||
a_ClosestPlayer->DeltaExperience(m_Reward);
|
||||
|
||||
m_World->BroadcastSoundEffect("random.orb", GetPosX(), GetPosY(), GetPosZ(), 0.5f, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
|
||||
m_World->BroadcastSoundEffect("random.orb", GetPosX(), GetPosY(), GetPosZ(), 0.5f, (0.75f + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
|
||||
|
||||
Destroy();
|
||||
}
|
||||
a_Distance.Normalize();
|
||||
a_Distance *= ((float) (5.5 - Distance));
|
||||
a_Distance *= (static_cast<float>(5.5 - Distance));
|
||||
SetSpeedX( a_Distance.x);
|
||||
SetSpeedY( a_Distance.y);
|
||||
SetSpeedZ( a_Distance.z);
|
||||
|
@ -38,7 +38,7 @@ void cFallingBlock::Tick(std::chrono::milliseconds a_Dt, cChunk & a_Chunk)
|
||||
// GetWorld()->BroadcastTeleportEntity(*this); // Test position
|
||||
|
||||
int BlockX = POSX_TOINT;
|
||||
int BlockY = (int)(GetPosY() - 0.5);
|
||||
int BlockY = static_cast<int>(GetPosY() - 0.5);
|
||||
int BlockZ = POSZ_TOINT;
|
||||
|
||||
if (BlockY < 0)
|
||||
|
@ -19,11 +19,11 @@ cFireChargeEntity::cFireChargeEntity(cEntity * a_Creator, double a_X, double a_Y
|
||||
|
||||
|
||||
|
||||
void cFireChargeEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
|
||||
void cFireChargeEntity::Explode(Vector3i a_Block)
|
||||
{
|
||||
if (m_World->GetBlock(a_BlockX, a_BlockY, a_BlockZ) == E_BLOCK_AIR)
|
||||
if (m_World->GetBlock(a_Block) == E_BLOCK_AIR)
|
||||
{
|
||||
m_World->SetBlock(a_BlockX, a_BlockY, a_BlockZ, E_BLOCK_FIRE, 1);
|
||||
m_World->SetBlock(a_Block.x, a_Block.y, a_Block.z, E_BLOCK_FIRE, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -34,7 +34,7 @@ void cFireChargeEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
|
||||
void cFireChargeEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
|
||||
{
|
||||
Destroy();
|
||||
Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
|
||||
Explode(a_HitPos.Floor());
|
||||
}
|
||||
|
||||
|
||||
@ -44,7 +44,7 @@ void cFireChargeEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_
|
||||
void cFireChargeEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
|
||||
{
|
||||
Destroy();
|
||||
Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
|
||||
Explode(a_HitPos.Floor());
|
||||
|
||||
// TODO: Some entities are immune to hits
|
||||
a_EntityHit.StartBurning(5 * 20); // 5 seconds of burning
|
||||
|
@ -32,7 +32,7 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
void Explode(int a_BlockX, int a_BlockY, int a_BlockZ);
|
||||
void Explode(Vector3i a_Block);
|
||||
|
||||
// cProjectileEntity overrides:
|
||||
virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
|
||||
|
@ -19,9 +19,9 @@ cGhastFireballEntity::cGhastFireballEntity(cEntity * a_Creator, double a_X, doub
|
||||
|
||||
|
||||
|
||||
void cGhastFireballEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
|
||||
void cGhastFireballEntity::Explode(Vector3i a_Block)
|
||||
{
|
||||
m_World->DoExplosionAt(1, a_BlockX, a_BlockY, a_BlockZ, true, esGhastFireball, this);
|
||||
m_World->DoExplosionAt(1, a_Block.x, a_Block.y, a_Block.z, true, esGhastFireball, this);
|
||||
}
|
||||
|
||||
|
||||
@ -31,7 +31,7 @@ void cGhastFireballEntity::Explode(int a_BlockX, int a_BlockY, int a_BlockZ)
|
||||
void cGhastFireballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace)
|
||||
{
|
||||
Destroy();
|
||||
Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
|
||||
Explode(a_HitPos.Floor());
|
||||
}
|
||||
|
||||
|
||||
@ -41,5 +41,5 @@ void cGhastFireballEntity::OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace
|
||||
void cGhastFireballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d & a_HitPos)
|
||||
{
|
||||
Destroy();
|
||||
Explode((int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z));
|
||||
Explode(a_HitPos.Floor());
|
||||
}
|
||||
|
@ -32,7 +32,7 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
void Explode(int a_BlockX, int a_BlockY, int a_BlockZ);
|
||||
void Explode(Vector3i a_Block);
|
||||
|
||||
// cProjectileEntity overrides:
|
||||
virtual void OnHitSolidBlock(const Vector3d & a_HitPos, eBlockFace a_HitFace) override;
|
||||
|
@ -89,7 +89,9 @@ protected:
|
||||
case BLOCK_FACE_ZM: Dir = 2; break;
|
||||
case BLOCK_FACE_XM: Dir = 1; break;
|
||||
case BLOCK_FACE_XP: Dir = 3; break;
|
||||
default:
|
||||
case BLOCK_FACE_YP:
|
||||
case BLOCK_FACE_YM:
|
||||
case BLOCK_FACE_NONE:
|
||||
{
|
||||
// Uncomment when entities are initialised with their real data, instead of dummy values:
|
||||
// LOGINFO("Invalid facing (%d) in a cHangingEntity, adjusting to BLOCK_FACE_XP.", a_BlockFace);
|
||||
|
@ -62,7 +62,7 @@ void cItemFrame::KilledBy(TakeDamageInfo & a_TDI)
|
||||
return;
|
||||
}
|
||||
|
||||
if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPlayer() && !((cPlayer *)a_TDI.Attacker)->IsGameModeCreative())
|
||||
if ((a_TDI.Attacker != nullptr) && a_TDI.Attacker->IsPlayer() && !static_cast<cPlayer *>(a_TDI.Attacker)->IsGameModeCreative())
|
||||
{
|
||||
cItems Item;
|
||||
Item.push_back(m_Item);
|
||||
@ -83,7 +83,7 @@ void cItemFrame::KilledBy(TakeDamageInfo & a_TDI)
|
||||
|
||||
void cItemFrame::GetDrops(cItems & a_Items, cEntity * a_Killer)
|
||||
{
|
||||
if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
|
||||
if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !static_cast<cPlayer *>(a_Killer)->IsGameModeCreative())
|
||||
{
|
||||
a_Items.push_back(cItem(E_ITEM_ITEM_FRAME));
|
||||
}
|
||||
@ -96,7 +96,7 @@ void cItemFrame::GetDrops(cItems & a_Items, cEntity * a_Killer)
|
||||
void cItemFrame::SpawnOn(cClientHandle & a_ClientHandle)
|
||||
{
|
||||
super::SpawnOn(a_ClientHandle);
|
||||
a_ClientHandle.SendSpawnObject(*this, 71, GetProtocolFacing(), (Byte)GetYaw(), (Byte)GetPitch());
|
||||
a_ClientHandle.SendSpawnObject(*this, 71, GetProtocolFacing(), static_cast<Byte>(GetYaw()), static_cast<Byte>(GetPitch()));
|
||||
a_ClientHandle.SendEntityMetadata(*this);
|
||||
}
|
||||
|
||||
|
@ -106,7 +106,7 @@ cMinecart::cMinecart(ePayload a_Payload, double a_X, double a_Y, double a_Z) :
|
||||
|
||||
void cMinecart::SpawnOn(cClientHandle & a_ClientHandle)
|
||||
{
|
||||
a_ClientHandle.SendSpawnVehicle(*this, 10, (char)m_Payload); // 10 = Minecarts
|
||||
a_ClientHandle.SendSpawnVehicle(*this, 10, static_cast<char>(m_Payload)); // 10 = Minecarts
|
||||
a_ClientHandle.SendEntityMetadata(*this);
|
||||
}
|
||||
|
||||
@ -725,11 +725,11 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
|
||||
{
|
||||
if (GetSpeedZ() > 0)
|
||||
{
|
||||
BLOCKTYPE Block = m_World->GetBlock(POSX_TOINT, POSY_TOINT, (int)ceil(GetPosZ()));
|
||||
BLOCKTYPE Block = m_World->GetBlock(POSX_TOINT, POSY_TOINT, static_cast<int>(ceil(GetPosZ())));
|
||||
if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
|
||||
{
|
||||
// We could try to detect a block in front based purely on coordinates, but xoft made a bounding box system - why not use? :P
|
||||
cBoundingBox bbBlock(Vector3d(POSX_TOINT, POSY_TOINT, (int)ceil(GetPosZ())), 0.5, 1);
|
||||
cBoundingBox bbBlock(Vector3d(POSX_TOINT, POSY_TOINT, static_cast<int>(ceil(GetPosZ()))), 0.5, 1);
|
||||
cBoundingBox bbMinecart(Vector3d(GetPosX(), floor(GetPosY()), GetPosZ()), GetWidth() / 2, GetHeight());
|
||||
|
||||
if (bbBlock.DoesIntersect(bbMinecart))
|
||||
@ -762,10 +762,10 @@ bool cMinecart::TestBlockCollision(NIBBLETYPE a_RailMeta)
|
||||
{
|
||||
if (GetSpeedX() > 0)
|
||||
{
|
||||
BLOCKTYPE Block = m_World->GetBlock((int)ceil(GetPosX()), POSY_TOINT, POSZ_TOINT);
|
||||
BLOCKTYPE Block = m_World->GetBlock(static_cast<int>(ceil(GetPosX())), POSY_TOINT, POSZ_TOINT);
|
||||
if (!IsBlockRail(Block) && cBlockInfo::IsSolid(Block))
|
||||
{
|
||||
cBoundingBox bbBlock(Vector3d((int)ceil(GetPosX()), POSY_TOINT, POSZ_TOINT), 0.5, 1);
|
||||
cBoundingBox bbBlock(Vector3d(static_cast<int>(ceil(GetPosX())), POSY_TOINT, POSZ_TOINT), 0.5, 1);
|
||||
cBoundingBox bbMinecart(Vector3d(GetPosX(), floor(GetPosY()), GetPosZ()), GetWidth() / 2, GetHeight());
|
||||
|
||||
if (bbBlock.DoesIntersect(bbMinecart))
|
||||
@ -1003,7 +1003,7 @@ bool cMinecart::TestEntityCollision(NIBBLETYPE a_RailMeta)
|
||||
|
||||
bool cMinecart::DoTakeDamage(TakeDamageInfo & TDI)
|
||||
{
|
||||
if ((TDI.Attacker != nullptr) && TDI.Attacker->IsPlayer() && ((cPlayer *)TDI.Attacker)->IsGameModeCreative())
|
||||
if ((TDI.Attacker != nullptr) && TDI.Attacker->IsPlayer() && static_cast<cPlayer *>(TDI.Attacker)->IsGameModeCreative())
|
||||
{
|
||||
Destroy();
|
||||
TDI.FinalDamage = GetMaxHealth(); // Instant hit for creative
|
||||
@ -1051,11 +1051,6 @@ bool cMinecart::DoTakeDamage(TakeDamageInfo & TDI)
|
||||
Drops.push_back(cItem(E_ITEM_MINECART_WITH_HOPPER, 1, 0));
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
ASSERT(!"Unhandled minecart type when spawning pickup!");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ());
|
||||
|
@ -33,7 +33,7 @@ void cPainting::SpawnOn(cClientHandle & a_Client)
|
||||
|
||||
void cPainting::GetDrops(cItems & a_Items, cEntity * a_Killer)
|
||||
{
|
||||
if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !((cPlayer *)a_Killer)->IsGameModeCreative())
|
||||
if ((a_Killer != nullptr) && a_Killer->IsPlayer() && !static_cast<cPlayer *>(a_Killer)->IsGameModeCreative())
|
||||
{
|
||||
a_Items.push_back(cItem(E_ITEM_PAINTING));
|
||||
}
|
||||
|
@ -75,10 +75,10 @@ void cPawn::AddEntityEffect(cEntityEffect::eType a_EffectType, int a_Duration, s
|
||||
{
|
||||
return;
|
||||
}
|
||||
a_Duration = (int)(a_Duration * a_DistanceModifier);
|
||||
a_Duration = static_cast<int>(a_Duration * a_DistanceModifier);
|
||||
|
||||
m_EntityEffects[a_EffectType] = cEntityEffect::CreateEntityEffect(a_EffectType, a_Duration, a_Intensity, a_DistanceModifier);
|
||||
m_World->BroadcastEntityEffect(*this, a_EffectType, a_Intensity, a_Duration);
|
||||
m_World->BroadcastEntityEffect(*this, a_EffectType, a_Intensity, static_cast<short>(a_Duration));
|
||||
m_EntityEffects[a_EffectType]->OnActivate(*this);
|
||||
}
|
||||
|
||||
|
@ -38,7 +38,7 @@ public:
|
||||
Vector3d EntityPos = a_Entity->GetPosition();
|
||||
double Distance = (EntityPos - m_Position).Length();
|
||||
|
||||
cItem & Item = ((cPickup *)a_Entity)->GetItem();
|
||||
cItem & Item = static_cast<cPickup *>(a_Entity)->GetItem();
|
||||
if ((Distance < 1.2) && Item.IsEqual(m_Pickup->GetItem()))
|
||||
{
|
||||
short CombineCount = Item.m_ItemCount;
|
||||
@ -52,7 +52,7 @@ public:
|
||||
return false;
|
||||
}
|
||||
|
||||
m_Pickup->GetItem().AddCount((char)CombineCount);
|
||||
m_Pickup->GetItem().AddCount(static_cast<char>(CombineCount));
|
||||
Item.m_ItemCount -= CombineCount;
|
||||
|
||||
if (Item.m_ItemCount <= 0)
|
||||
@ -230,7 +230,7 @@ bool cPickup::CollectedBy(cPlayer & a_Dest)
|
||||
m_World->BroadcastCollectEntity(*this, a_Dest);
|
||||
|
||||
// Also send the "pop" sound effect with a somewhat random pitch (fast-random using EntityID ;)
|
||||
m_World->BroadcastSoundEffect("random.pop", GetPosX(), GetPosY(), GetPosZ(), 0.5, (float)(0.75 + ((float)((GetUniqueID() * 23) % 32)) / 64));
|
||||
m_World->BroadcastSoundEffect("random.pop", GetPosX(), GetPosY(), GetPosZ(), 0.5, (0.75f + (static_cast<float>((GetUniqueID() * 23) % 32)) / 64));
|
||||
if (m_Item.m_ItemCount <= 0)
|
||||
{
|
||||
// All of the pickup has been collected, schedule the pickup for destroying
|
||||
|
@ -30,7 +30,7 @@
|
||||
|
||||
|
||||
/// Converts an angle in radians into a byte representation used by the network protocol
|
||||
#define ANGLE_TO_PROTO(X) (Byte)(X * 255 / 360)
|
||||
#define ANGLE_TO_PROTO(X) static_cast<Byte>(X * 255 / 360)
|
||||
|
||||
|
||||
|
||||
@ -222,7 +222,7 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a
|
||||
m_ProjectileKind(a_Kind),
|
||||
m_CreatorData(
|
||||
((a_Creator != nullptr) ? a_Creator->GetUniqueID() : cEntity::INVALID_ID),
|
||||
((a_Creator != nullptr) ? (a_Creator->IsPlayer() ? ((cPlayer *)a_Creator)->GetName() : "") : ""),
|
||||
((a_Creator != nullptr) ? (a_Creator->IsPlayer() ? static_cast<cPlayer *>(a_Creator)->GetName() : "") : ""),
|
||||
((a_Creator != nullptr) ? a_Creator->GetEquippedWeapon().m_Enchantments : cEnchantments())
|
||||
),
|
||||
m_IsInGround(false)
|
||||
@ -238,7 +238,7 @@ cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, double a
|
||||
cProjectileEntity::cProjectileEntity(eKind a_Kind, cEntity * a_Creator, const Vector3d & a_Pos, const Vector3d & a_Speed, double a_Width, double a_Height) :
|
||||
super(etProjectile, a_Pos.x, a_Pos.y, a_Pos.z, a_Width, a_Height),
|
||||
m_ProjectileKind(a_Kind),
|
||||
m_CreatorData(a_Creator->GetUniqueID(), a_Creator->IsPlayer() ? ((cPlayer *)a_Creator)->GetName() : "", a_Creator->GetEquippedWeapon().m_Enchantments),
|
||||
m_CreatorData(a_Creator->GetUniqueID(), a_Creator->IsPlayer() ? static_cast<cPlayer *>(a_Creator)->GetName() : "", a_Creator->GetEquippedWeapon().m_Enchantments),
|
||||
m_IsInGround(false)
|
||||
{
|
||||
SetSpeed(a_Speed);
|
||||
@ -281,6 +281,7 @@ cProjectileEntity * cProjectileEntity::Create(eKind a_Kind, cEntity * a_Creator,
|
||||
|
||||
return new cFireworkEntity(a_Creator, a_X, a_Y, a_Z, *a_Item);
|
||||
}
|
||||
case pkFishingFloat: break;
|
||||
}
|
||||
|
||||
LOGWARNING("%s: Unknown projectile kind: %d", __FUNCTION__, a_Kind);
|
||||
|
@ -9,7 +9,7 @@
|
||||
|
||||
|
||||
/// Converts an angle in radians into a byte representation used by the network protocol
|
||||
#define ANGLE_TO_PROTO(X) (Byte)(X * 255 / 360)
|
||||
#define ANGLE_TO_PROTO(X) static_cast<Byte>(X * 255 / 360)
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// cSplashPotionEntityCallback:
|
||||
@ -51,7 +51,7 @@ public:
|
||||
double Reduction = -0.25 * SplashDistance + 1.0;
|
||||
Reduction = std::max(Reduction, 0.0);
|
||||
|
||||
((cPawn *) a_Entity)->AddEntityEffect(m_EntityEffectType, m_EntityEffect.GetDuration(), m_EntityEffect.GetIntensity(), Reduction);
|
||||
static_cast<cPawn *>(a_Entity)->AddEntityEffect(m_EntityEffectType, m_EntityEffect.GetDuration(), m_EntityEffect.GetIntensity(), Reduction);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -116,7 +116,13 @@ void cSplashPotionEntity::Splash(const Vector3d & a_HitPos)
|
||||
cSplashPotionCallback Callback(a_HitPos, m_EntityEffectType, m_EntityEffect);
|
||||
m_World->ForEachEntity(Callback);
|
||||
|
||||
m_World->BroadcastSoundParticleEffect(2002, (int)floor(a_HitPos.x), (int)floor(a_HitPos.y), (int)floor(a_HitPos.z), m_PotionColor);
|
||||
m_World->BroadcastSoundParticleEffect(
|
||||
2002,
|
||||
FloorC(a_HitPos.x),
|
||||
FloorC(a_HitPos.y),
|
||||
FloorC(a_HitPos.z),
|
||||
m_PotionColor
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
|
@ -77,9 +77,9 @@ void cThrownEnderPearlEntity::TeleportCreator(const Vector3d & a_HitPos)
|
||||
class cProjectileCreatorCallbackForPlayers : public cPlayerListCallback
|
||||
{
|
||||
public:
|
||||
cProjectileCreatorCallbackForPlayers(cEntity * a_Attacker, Vector3i a_HitPos) :
|
||||
cProjectileCreatorCallbackForPlayers(cEntity * a_Attacker, Vector3i a_CallbackHitPos) :
|
||||
m_Attacker(a_Attacker),
|
||||
m_HitPos(a_HitPos)
|
||||
m_HitPos(a_CallbackHitPos)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -32,7 +32,7 @@ void cThrownSnowballEntity::OnHitEntity(cEntity & a_EntityHit, const Vector3d &
|
||||
int TotalDamage = 0;
|
||||
if (a_EntityHit.IsMob())
|
||||
{
|
||||
eMonsterType MobType = ((cMonster &) a_EntityHit).GetMobType();
|
||||
eMonsterType MobType = static_cast<cMonster &>(a_EntityHit).GetMobType();
|
||||
if (MobType == mtBlaze)
|
||||
{
|
||||
TotalDamage = 3;
|
||||
|
@ -77,7 +77,7 @@ void cFurnaceRecipe::ReloadRecipes(void)
|
||||
size_t FirstCommentSymbol = ParsingLine.find('#');
|
||||
if ((FirstCommentSymbol != AString::npos) && (FirstCommentSymbol != 0))
|
||||
{
|
||||
ParsingLine.erase(ParsingLine.begin() + (const long)FirstCommentSymbol, ParsingLine.end());
|
||||
ParsingLine.erase(ParsingLine.begin() + static_cast<const long>(FirstCommentSymbol), ParsingLine.end());
|
||||
}
|
||||
|
||||
switch (ParsingLine[0])
|
||||
@ -121,7 +121,7 @@ void cFurnaceRecipe::AddFuelFromLine(const AString & a_Line, unsigned int a_Line
|
||||
const AStringVector & Sides = StringSplit(Line, "=");
|
||||
if (Sides.size() != 2)
|
||||
{
|
||||
LOGWARNING("furnace.txt: line %d: A single '=' was expected, got %d", a_LineNum, (int)Sides.size() - 1);
|
||||
LOGWARNING("furnace.txt: line %d: A single '=' was expected, got " SIZE_T_FMT, a_LineNum, Sides.size() - 1);
|
||||
LOGINFO("Offending line: \"%s\"", a_Line.c_str());
|
||||
return;
|
||||
}
|
||||
@ -163,7 +163,7 @@ void cFurnaceRecipe::AddRecipeFromLine(const AString & a_Line, unsigned int a_Li
|
||||
const AStringVector & Sides = StringSplit(Line, "=");
|
||||
if (Sides.size() != 2)
|
||||
{
|
||||
LOGWARNING("furnace.txt: line %d: A single '=' was expected, got %d", a_LineNum, (int)Sides.size() - 1);
|
||||
LOGWARNING("furnace.txt: line %d: A single '=' was expected, got " SIZE_T_FMT, a_LineNum, Sides.size() - 1);
|
||||
LOGINFO("Offending line: \"%s\"", a_Line.c_str());
|
||||
return;
|
||||
}
|
||||
|
@ -49,16 +49,16 @@ void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// cBioGenCache:
|
||||
|
||||
cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, int a_CacheSize) :
|
||||
cBioGenCache::cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize) :
|
||||
m_BioGenToCache(a_BioGenToCache),
|
||||
m_CacheSize(a_CacheSize),
|
||||
m_CacheOrder(new int[a_CacheSize]),
|
||||
m_CacheOrder(new size_t[a_CacheSize]),
|
||||
m_CacheData(new sCacheData[a_CacheSize]),
|
||||
m_NumHits(0),
|
||||
m_NumMisses(0),
|
||||
m_TotalChain(0)
|
||||
{
|
||||
for (int i = 0; i < m_CacheSize; i++)
|
||||
for (size_t i = 0; i < m_CacheSize; i++)
|
||||
{
|
||||
m_CacheOrder[i] = i;
|
||||
m_CacheData[i].m_ChunkX = 0x7fffffff;
|
||||
@ -90,7 +90,7 @@ void cBioGenCache::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a
|
||||
LOGD("BioGenCache: Avg cache chain length: %.2f", (float)m_TotalChain / m_NumHits);
|
||||
}
|
||||
|
||||
for (int i = 0; i < m_CacheSize; i++)
|
||||
for (size_t i = 0; i < m_CacheSize; i++)
|
||||
{
|
||||
if (
|
||||
(m_CacheData[m_CacheOrder[i]].m_ChunkX != a_ChunkX) ||
|
||||
@ -100,10 +100,10 @@ void cBioGenCache::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a
|
||||
continue;
|
||||
}
|
||||
// Found it in the cache
|
||||
int Idx = m_CacheOrder[i];
|
||||
size_t Idx = m_CacheOrder[i];
|
||||
|
||||
// Move to front:
|
||||
for (int j = i; j > 0; j--)
|
||||
for (size_t j = i; j > 0; j--)
|
||||
{
|
||||
m_CacheOrder[j] = m_CacheOrder[j - 1];
|
||||
}
|
||||
@ -122,8 +122,8 @@ void cBioGenCache::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap & a
|
||||
m_BioGenToCache->GenBiomes(a_ChunkX, a_ChunkZ, a_BiomeMap);
|
||||
|
||||
// Insert it as the first item in the MRU order:
|
||||
int Idx = m_CacheOrder[m_CacheSize - 1];
|
||||
for (int i = m_CacheSize - 1; i > 0; i--)
|
||||
size_t Idx = m_CacheOrder[m_CacheSize - 1];
|
||||
for (size_t i = m_CacheSize - 1; i > 0; i--)
|
||||
{
|
||||
m_CacheOrder[i] = m_CacheOrder[i - 1];
|
||||
} // for i - m_CacheOrder[]
|
||||
@ -278,7 +278,7 @@ void cBioGenCheckerboard::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::Biome
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int Add = cChunkDef::Width * a_ChunkX + x;
|
||||
int BiomeIdx = (((Base + Add / m_BiomeSize) % m_BiomesCount) + m_BiomesCount) % m_BiomesCount; // Need to add and modulo twice because of negative numbers
|
||||
size_t BiomeIdx = static_cast<size_t>((((Base + Add / m_BiomeSize) % m_BiomesCount) + m_BiomesCount) % m_BiomesCount); // Need to add and modulo twice because of negative numbers
|
||||
a_BiomeMap[x + cChunkDef::Width * z] = m_Biomes[BiomeIdx];
|
||||
}
|
||||
}
|
||||
@ -314,7 +314,7 @@ void cBioGenVoronoi::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap &
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int VoronoiCellValue = m_Voronoi.GetValueAt(BaseX + x, AbsoluteZ) / 8;
|
||||
cChunkDef::SetBiome(a_BiomeMap, x, z, m_Biomes[VoronoiCellValue % m_BiomesCount]);
|
||||
cChunkDef::SetBiome(a_BiomeMap, x, z, m_Biomes[static_cast<size_t>(VoronoiCellValue % m_BiomesCount)]);
|
||||
} // for x
|
||||
} // for z
|
||||
}
|
||||
@ -363,7 +363,7 @@ void cBioGenDistortedVoronoi::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::B
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int VoronoiCellValue = m_Voronoi.GetValueAt(DistortX[x][z], DistortZ[x][z]) / 8;
|
||||
cChunkDef::SetBiome(a_BiomeMap, x, z, m_Biomes[VoronoiCellValue % m_BiomesCount]);
|
||||
cChunkDef::SetBiome(a_BiomeMap, x, z, m_Biomes[static_cast<size_t>(VoronoiCellValue % m_BiomesCount)]);
|
||||
} // for x
|
||||
} // for z
|
||||
}
|
||||
@ -785,7 +785,7 @@ void cBioGenTwoLevel::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
|
||||
{
|
||||
int SeedX, SeedZ, MinDist2;
|
||||
int BiomeGroup = m_VoronoiLarge.GetValueAt(DistortX[x][z], DistortZ[x][z], SeedX, SeedZ, MinDist2) / 7;
|
||||
int BiomeIdx = m_VoronoiSmall.GetValueAt(DistortX[x][z], DistortZ[x][z], SeedX, SeedZ, MinDist2) / 11;
|
||||
size_t BiomeIdx = static_cast<size_t>(m_VoronoiSmall.GetValueAt(DistortX[x][z], DistortZ[x][z], SeedX, SeedZ, MinDist2) / 11);
|
||||
int MinDist1 = (DistortX[x][z] - SeedX) * (DistortX[x][z] - SeedX) + (DistortZ[x][z] - SeedZ) * (DistortZ[x][z] - SeedZ);
|
||||
cChunkDef::SetBiome(a_BiomeMap, x, z, SelectBiome(BiomeGroup, BiomeIdx, (MinDist1 < MinDist2 / 4) ? 1 : 0));
|
||||
}
|
||||
@ -796,7 +796,7 @@ void cBioGenTwoLevel::GenBiomes(int a_ChunkX, int a_ChunkZ, cChunkDef::BiomeMap
|
||||
|
||||
|
||||
|
||||
EMCSBiome cBioGenTwoLevel::SelectBiome(int a_BiomeGroup, int a_BiomeIdx, int a_DistLevel)
|
||||
EMCSBiome cBioGenTwoLevel::SelectBiome(int a_BiomeGroup, size_t a_BiomeIdx, int a_DistLevel)
|
||||
{
|
||||
// TODO: Move this into settings
|
||||
struct BiomeLevels
|
||||
@ -900,7 +900,7 @@ EMCSBiome cBioGenTwoLevel::SelectBiome(int a_BiomeGroup, int a_BiomeIdx, int a_D
|
||||
{ bgMesa, ARRAYCOUNT(bgMesa), },
|
||||
{ bgDenseTrees, ARRAYCOUNT(bgDenseTrees), },
|
||||
} ;
|
||||
size_t Group = a_BiomeGroup % ARRAYCOUNT(BiomeGroups);
|
||||
size_t Group = static_cast<size_t>(a_BiomeGroup) % ARRAYCOUNT(BiomeGroups);
|
||||
size_t Index = a_BiomeIdx % BiomeGroups[Group].Count;
|
||||
return (a_DistLevel > 0) ? BiomeGroups[Group].Biomes[Index].InnerBiome : BiomeGroups[Group].Biomes[Index].OuterBiome;
|
||||
}
|
||||
|
@ -48,7 +48,7 @@ class cBioGenCache :
|
||||
typedef cBiomeGen super;
|
||||
|
||||
public:
|
||||
cBioGenCache(cBiomeGenPtr a_BioGenToCache, int a_CacheSize);
|
||||
cBioGenCache(cBiomeGenPtr a_BioGenToCache, size_t a_CacheSize);
|
||||
virtual ~cBioGenCache();
|
||||
|
||||
protected:
|
||||
@ -63,8 +63,8 @@ protected:
|
||||
} ;
|
||||
|
||||
// To avoid moving large amounts of data for the MRU behavior, we MRU-ize indices to an array of the actual data
|
||||
int m_CacheSize;
|
||||
int * m_CacheOrder; // MRU-ized order, indices into m_CacheData array
|
||||
size_t m_CacheSize;
|
||||
size_t * m_CacheOrder; // MRU-ized order, indices into m_CacheData array
|
||||
sCacheData * m_CacheData; // m_CacheData[m_CacheOrder[0]] is the most recently used
|
||||
|
||||
// Cache statistics
|
||||
@ -311,7 +311,7 @@ protected:
|
||||
/// Selects biome from the specified biome group, based on the specified index.
|
||||
/// Note that both params may overflow
|
||||
/// a_DistLevel is either 0 or 1; zero when it is at the edge of the small Voronoi cell, 1 near the center
|
||||
EMCSBiome SelectBiome(int a_BiomeGroup, int a_BiomeIdx, int a_DistLevel);
|
||||
EMCSBiome SelectBiome(int a_BiomeGroup, size_t a_BiomeIdx, int a_DistLevel);
|
||||
} ;
|
||||
|
||||
|
||||
|
@ -72,6 +72,32 @@ SET (HDRS
|
||||
VillageGen.h
|
||||
)
|
||||
|
||||
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
|
||||
set_source_files_properties(BioGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum -Wno-error=old-style-cast")
|
||||
set_source_files_properties(Caves.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(ChunkGenerator.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(CompoGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(CompoGenBiomal.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors -Wno-error=old-style-cast")
|
||||
set_source_files_properties(ComposableGenerator.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum -Wno-error=old-style-cast")
|
||||
set_source_files_properties(DistortedHeightmap.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(EndGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(FinishGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum -Wno-error=switch")
|
||||
set_source_files_properties(HeiGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(NetherFortGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(Noise3DGenerator.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(PieceGenerator.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(Prefab.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(RainbowRoadsGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(Ravines.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(RoughRavines.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=float-equal -Wno-error=old-style-cast")
|
||||
set_source_files_properties(StructGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=switch-enum -Wno-error=switch -Wno-error=old-style-cast")
|
||||
set_source_files_properties(ShapeGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(TestRailsGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors")
|
||||
set_source_files_properties(TwoHeights.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=old-style-cast")
|
||||
set_source_files_properties(UnderwaterBaseGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors -Wno-error=switch-enum")
|
||||
set_source_files_properties(VillageGen.cpp PROPERTIES COMPILE_FLAGS "-Wno-error=global-constructors -Wno-error=switch-enum")
|
||||
endif()
|
||||
|
||||
if(NOT MSVC)
|
||||
add_library(Generating ${SRCS} ${HDRS})
|
||||
|
||||
|
@ -134,7 +134,7 @@ EMCSBiome cChunkDesc::GetBiome(int a_RelX, int a_RelZ)
|
||||
|
||||
|
||||
|
||||
void cChunkDesc::SetHeight(int a_RelX, int a_RelZ, int a_Height)
|
||||
void cChunkDesc::SetHeight(int a_RelX, int a_RelZ, HEIGHTTYPE a_Height)
|
||||
{
|
||||
cChunkDef::SetHeight(m_HeightMap, a_RelX, a_RelZ, a_Height);
|
||||
}
|
||||
@ -143,7 +143,7 @@ void cChunkDesc::SetHeight(int a_RelX, int a_RelZ, int a_Height)
|
||||
|
||||
|
||||
|
||||
int cChunkDesc::GetHeight(int a_RelX, int a_RelZ)
|
||||
HEIGHTTYPE cChunkDesc::GetHeight(int a_RelX, int a_RelZ)
|
||||
{
|
||||
return cChunkDef::GetHeight(m_HeightMap, a_RelX, a_RelZ);
|
||||
}
|
||||
@ -158,7 +158,7 @@ void cChunkDesc::SetHeightFromShape(const Shape & a_Shape)
|
||||
{
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
for (int y = cChunkDef::Height - 1; y > 0; y--)
|
||||
for (HEIGHTTYPE y = cChunkDef::Height - 1; y > 0; y--)
|
||||
{
|
||||
if (a_Shape[y + x * 256 + z * 16 * 256] != 0)
|
||||
{
|
||||
@ -612,8 +612,8 @@ void cChunkDesc::UpdateHeightmap(void)
|
||||
{
|
||||
for (int z = 0; z < cChunkDef::Width; z++)
|
||||
{
|
||||
int Height = 0;
|
||||
for (int y = cChunkDef::Height - 1; y > 0; y--)
|
||||
HEIGHTTYPE Height = 0;
|
||||
for (HEIGHTTYPE y = cChunkDef::Height - 1; y > 0; y--)
|
||||
{
|
||||
BLOCKTYPE BlockType = GetBlockType(x, y, z);
|
||||
if (BlockType != E_BLOCK_AIR)
|
||||
@ -636,7 +636,7 @@ void cChunkDesc::CompressBlockMetas(cChunkDef::BlockNibbles & a_DestMetas)
|
||||
const NIBBLETYPE * AreaMetas = m_BlockArea.GetBlockMetas();
|
||||
for (size_t i = 0; i < ARRAYCOUNT(a_DestMetas); i++)
|
||||
{
|
||||
a_DestMetas[i] = AreaMetas[2 * i] | (AreaMetas[2 * i + 1] << 4);
|
||||
a_DestMetas[i] = static_cast<NIBBLETYPE>(AreaMetas[2 * i] | (AreaMetas[2 * i + 1] << 4));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -65,8 +65,8 @@ public:
|
||||
|
||||
// These operate on the heightmap, so they could get out of sync with the data
|
||||
// Use UpdateHeightmap() to re-calculate heightmap from the block data
|
||||
void SetHeight(int a_RelX, int a_RelZ, int a_Height);
|
||||
int GetHeight(int a_RelX, int a_RelZ);
|
||||
void SetHeight(int a_RelX, int a_RelZ, HEIGHTTYPE a_Height);
|
||||
HEIGHTTYPE GetHeight(int a_RelX, int a_RelZ);
|
||||
|
||||
// tolua_end
|
||||
|
||||
@ -204,10 +204,10 @@ public:
|
||||
|
||||
// Accessors used by cChunkGenerator::Generator descendants:
|
||||
inline cChunkDef::BiomeMap & GetBiomeMap (void) { return m_BiomeMap; }
|
||||
inline cChunkDef::BlockTypes & GetBlockTypes (void) { return *((cChunkDef::BlockTypes *)m_BlockArea.GetBlockTypes()); }
|
||||
inline cChunkDef::BlockTypes & GetBlockTypes (void) { return *(reinterpret_cast<cChunkDef::BlockTypes *>(m_BlockArea.GetBlockTypes())); }
|
||||
// CANNOT, different compression!
|
||||
// inline cChunkDef::BlockNibbles & GetBlockMetas (void) { return *((cChunkDef::BlockNibbles *)m_BlockArea.GetBlockMetas()); }
|
||||
inline BlockNibbleBytes & GetBlockMetasUncompressed(void) { return *((BlockNibbleBytes *)m_BlockArea.GetBlockMetas()); }
|
||||
inline BlockNibbleBytes & GetBlockMetasUncompressed(void) { return *(reinterpret_cast<BlockNibbleBytes *>(m_BlockArea.GetBlockMetas())); }
|
||||
inline cChunkDef::HeightMap & GetHeightMap (void) { return m_HeightMap; }
|
||||
inline cEntityList & GetEntities (void) { return m_Entities; }
|
||||
inline cBlockEntityList & GetBlockEntities (void) { return m_BlockEntities; }
|
||||
|
@ -4,6 +4,9 @@
|
||||
// Implements the cCompoGenBiomal class representing the biome-aware composition generator
|
||||
|
||||
#include "Globals.h"
|
||||
|
||||
#include "CompoGenBiomal.h"
|
||||
|
||||
#include "ComposableGenerator.h"
|
||||
#include "../IniFile.h"
|
||||
#include "../Noise/Noise.h"
|
||||
@ -192,7 +195,7 @@ public:
|
||||
|
||||
protected:
|
||||
/** The block height at which water is generated instead of air. */
|
||||
int m_SeaLevel;
|
||||
HEIGHTTYPE m_SeaLevel;
|
||||
|
||||
/** The pattern used for mesa biomes. Initialized by seed on generator creation. */
|
||||
cPattern::BlockInfo m_MesaPattern[2 * cChunkDef::Height];
|
||||
@ -221,7 +224,7 @@ protected:
|
||||
|
||||
virtual void InitializeCompoGen(cIniFile & a_IniFile) override
|
||||
{
|
||||
m_SeaLevel = a_IniFile.GetValueSetI("Generator", "SeaLevel", m_SeaLevel);
|
||||
m_SeaLevel = static_cast<HEIGHTTYPE>(a_IniFile.GetValueSetI("Generator", "SeaLevel", m_SeaLevel));
|
||||
}
|
||||
|
||||
|
||||
@ -231,7 +234,7 @@ protected:
|
||||
{
|
||||
// In a loop, choose whether to use one, two or three layers of stained clay, then choose a color and width for each layer
|
||||
// Separate each group with another layer of hardened clay
|
||||
cNoise patternNoise((unsigned)a_Seed);
|
||||
cNoise patternNoise(a_Seed);
|
||||
static NIBBLETYPE allowedColors[] =
|
||||
{
|
||||
E_META_STAINED_CLAY_YELLOW,
|
||||
@ -265,8 +268,8 @@ protected:
|
||||
rnd /= 2;
|
||||
for (int lay = 0; lay < numLayers; lay++)
|
||||
{
|
||||
int numBlocks = layerSizes[(rnd % ARRAYCOUNT(layerSizes))];
|
||||
NIBBLETYPE Color = allowedColors[(rnd / 4) % ARRAYCOUNT(allowedColors)];
|
||||
int numBlocks = layerSizes[(static_cast<size_t>(rnd) % ARRAYCOUNT(layerSizes))];
|
||||
NIBBLETYPE Color = allowedColors[static_cast<size_t>(rnd / 4) % ARRAYCOUNT(allowedColors)];
|
||||
if (
|
||||
((numBlocks == 3) && (numLayers == 2)) || // In two-layer mode disallow the 3-high layers:
|
||||
(Color == E_META_STAINED_CLAY_WHITE)) // White stained clay can ever be only 1 block high
|
||||
@ -411,7 +414,12 @@ protected:
|
||||
FillColumnPattern(a_ChunkDesc, a_RelX, a_RelZ, Pattern, a_ShapeColumn);
|
||||
return;
|
||||
}
|
||||
default:
|
||||
case biInvalidBiome:
|
||||
case biHell:
|
||||
case biSky:
|
||||
case biNumBiomes:
|
||||
case biVariant:
|
||||
case biNumVariantBiomes:
|
||||
{
|
||||
ASSERT(!"Unhandled biome");
|
||||
return;
|
||||
@ -427,7 +435,7 @@ protected:
|
||||
{
|
||||
bool HasHadWater = false;
|
||||
int PatternIdx = 0;
|
||||
int top = std::max(m_SeaLevel, a_ChunkDesc.GetHeight(a_RelX, a_RelZ));
|
||||
HEIGHTTYPE top = std::max(m_SeaLevel, a_ChunkDesc.GetHeight(a_RelX, a_RelZ));
|
||||
for (int y = top; y > 0; y--)
|
||||
{
|
||||
if (a_ShapeColumn[y] > 0)
|
||||
|
@ -221,11 +221,11 @@ void cComposableGenerator::InitBiomeGen(cIniFile & a_IniFile)
|
||||
if (MultiCacheLength > 0)
|
||||
{
|
||||
LOGD("Enabling multicache for biomegen of length %d.", MultiCacheLength);
|
||||
m_BiomeGen = cBiomeGenPtr(new cBioGenMulticache(m_BiomeGen, CacheSize, MultiCacheLength));
|
||||
m_BiomeGen = cBiomeGenPtr(new cBioGenMulticache(m_BiomeGen, static_cast<size_t>(CacheSize), static_cast<size_t>(MultiCacheLength)));
|
||||
}
|
||||
else
|
||||
{
|
||||
m_BiomeGen = cBiomeGenPtr(new cBioGenCache(m_BiomeGen, CacheSize));
|
||||
m_BiomeGen = cBiomeGenPtr(new cBioGenCache(m_BiomeGen, static_cast<size_t>(CacheSize)));
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -194,7 +194,7 @@ protected:
|
||||
{
|
||||
return;
|
||||
}
|
||||
a_ChunkDesc.SetBlockTypeMeta(RelX, m_FloorHeight + 1, RelZ, E_BLOCK_CHEST, (NIBBLETYPE)a_Chest.y);
|
||||
a_ChunkDesc.SetBlockTypeMeta(RelX, m_FloorHeight + 1, RelZ, E_BLOCK_CHEST, static_cast<NIBBLETYPE>(a_Chest.y));
|
||||
|
||||
// Fill the chest with random loot
|
||||
static const cLootProbab LootProbab[] =
|
||||
@ -217,7 +217,7 @@ protected:
|
||||
{ cItem(E_ITEM_NAME_TAG), 1, 1, 10 },
|
||||
} ;
|
||||
|
||||
cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(RelX, m_FloorHeight + 1, RelZ);
|
||||
cChestEntity * ChestEntity = static_cast<cChestEntity *>(a_ChunkDesc.GetBlockEntity(RelX, m_FloorHeight + 1, RelZ));
|
||||
ASSERT((ChestEntity != nullptr) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
|
||||
cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
|
||||
int NumSlots = 3 + ((Noise.IntNoise3DInt(a_Chest.x, a_Chest.y, a_Chest.z) / 11) % 4);
|
||||
|
@ -69,7 +69,7 @@ void cFinishGenNetherClumpFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
}
|
||||
|
||||
// Choose what block to use.
|
||||
NOISE_DATATYPE BlockType = m_Noise.IntNoise3D((int) ChunkX, y, (int) ChunkZ);
|
||||
NOISE_DATATYPE BlockType = m_Noise.IntNoise3D(static_cast<int>(ChunkX), y, static_cast<int>(ChunkZ));
|
||||
if (BlockType < -0.7)
|
||||
{
|
||||
TryPlaceClump(a_ChunkDesc, PosX, y, PosZ, E_BLOCK_BROWN_MUSHROOM);
|
||||
@ -260,13 +260,13 @@ void cFinishGenGlowStone::TryPlaceGlowstone(cChunkDesc & a_ChunkDesc, int a_RelX
|
||||
|
||||
for (int j = 0; j < a_Size; j++)
|
||||
{
|
||||
Vector3i Direction = AvailableDirections[m_Noise.IntNoise3DInt(CurrentPos.x, CurrentPos.y * i, CurrentPos.z) % ARRAYCOUNT(AvailableDirections)];
|
||||
Vector3i Direction = AvailableDirections[static_cast<size_t>(m_Noise.IntNoise3DInt(CurrentPos.x, CurrentPos.y * i, CurrentPos.z)) % ARRAYCOUNT(AvailableDirections)];
|
||||
int Attempts = 2; // multiply by 1 would make no difference, so multiply by 2 instead
|
||||
|
||||
while (Direction.Equals(PreviousDirection))
|
||||
{
|
||||
// To make the glowstone branches look better we want to make the direction change every time.
|
||||
Direction = AvailableDirections[m_Noise.IntNoise3DInt(CurrentPos.x, CurrentPos.y * i * Attempts, CurrentPos.z) % ARRAYCOUNT(AvailableDirections)];
|
||||
Direction = AvailableDirections[static_cast<size_t>(m_Noise.IntNoise3DInt(CurrentPos.x, CurrentPos.y * i * Attempts, CurrentPos.z)) % ARRAYCOUNT(AvailableDirections)];
|
||||
Attempts++;
|
||||
}
|
||||
|
||||
@ -438,7 +438,7 @@ void cFinishGenVines::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
continue;
|
||||
}
|
||||
|
||||
NIBBLETYPE Meta = Places[m_Noise.IntNoise3DInt(xx, y, zz) % Places.size()];
|
||||
NIBBLETYPE Meta = Places[static_cast<size_t>(m_Noise.IntNoise3DInt(xx, y, zz)) % Places.size()];
|
||||
a_ChunkDesc.SetBlockTypeMeta(x, y, z, E_BLOCK_VINES, Meta);
|
||||
}
|
||||
}
|
||||
@ -507,7 +507,7 @@ void cFinishGenSprinkleFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
for (int z = 0; z < cChunkDef::Width; z++)
|
||||
{
|
||||
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width + z;
|
||||
const float zz = (float)BlockZ;
|
||||
const float zz = static_cast<float>(BlockZ);
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width + x;
|
||||
@ -515,7 +515,7 @@ void cFinishGenSprinkleFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
int Top = a_ChunkDesc.GetHeight(x, z);
|
||||
HEIGHTTYPE Top = a_ChunkDesc.GetHeight(x, z);
|
||||
if (Top > 250)
|
||||
{
|
||||
// Nothing grows above Y=250
|
||||
@ -528,7 +528,7 @@ void cFinishGenSprinkleFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
continue;
|
||||
}
|
||||
|
||||
const float xx = (float)BlockX;
|
||||
const float xx = static_cast<float>(BlockX);
|
||||
float val1 = m_Noise.CubicNoise2D(xx * 0.1f, zz * 0.1f);
|
||||
float val2 = m_Noise.CubicNoise2D(xx * 0.01f, zz * 0.01f);
|
||||
switch (a_ChunkDesc.GetBlockType(x, Top, z))
|
||||
@ -563,7 +563,7 @@ void cFinishGenSprinkleFoliage::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
}
|
||||
else if ((val1 > 0.5) && (val2 < -0.5))
|
||||
{
|
||||
a_ChunkDesc.SetBlockTypeMeta(x, ++Top, z, E_BLOCK_PUMPKIN, (int)(val3 * 8) % 4);
|
||||
a_ChunkDesc.SetBlockTypeMeta(x, ++Top, z, E_BLOCK_PUMPKIN, static_cast<int>(val3 * 8) % 4);
|
||||
}
|
||||
break;
|
||||
} // case E_BLOCK_GRASS
|
||||
@ -650,9 +650,9 @@ void cFinishGenSoulsandRims::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
continue;
|
||||
}
|
||||
|
||||
NOISE_DATATYPE NoiseX = ((NOISE_DATATYPE)(xx)) / 32;
|
||||
NOISE_DATATYPE NoiseY = ((NOISE_DATATYPE)(zz)) / 32;
|
||||
NOISE_DATATYPE CompBlock = m_Noise.CubicNoise3D(NoiseX, (float) (y) / 4, NoiseY);
|
||||
NOISE_DATATYPE NoiseX = (static_cast<NOISE_DATATYPE>(xx)) / 32;
|
||||
NOISE_DATATYPE NoiseY = (static_cast<NOISE_DATATYPE>(zz)) / 32;
|
||||
NOISE_DATATYPE CompBlock = m_Noise.CubicNoise3D(NoiseX, static_cast<float>(y) / 4, NoiseY);
|
||||
if (CompBlock < 0)
|
||||
{
|
||||
a_ChunkDesc.SetBlockType(x, y, z, E_BLOCK_SOULSAND);
|
||||
@ -676,7 +676,7 @@ void cFinishGenSnow::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
{
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int Height = a_ChunkDesc.GetHeight(x, z);
|
||||
HEIGHTTYPE Height = a_ChunkDesc.GetHeight(x, z);
|
||||
if (GetSnowStartHeight(a_ChunkDesc.GetBiome(x, z)) > Height)
|
||||
{
|
||||
// Height isn't high enough for snow to start forming.
|
||||
@ -775,7 +775,7 @@ void cFinishGenSingleTopBlock::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
continue;
|
||||
}
|
||||
|
||||
int Height = a_ChunkDesc.GetHeight(x, z);
|
||||
HEIGHTTYPE Height = a_ChunkDesc.GetHeight(x, z);
|
||||
if (Height >= cChunkDef::Height - 1)
|
||||
{
|
||||
// Too high up
|
||||
@ -918,7 +918,7 @@ void cFinishGenPreSimulator::CollapseSandGravel(
|
||||
}
|
||||
} // switch (GetBlock)
|
||||
} // for y
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, HeightY);
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, static_cast<HEIGHTTYPE>(HeightY));
|
||||
} // for x
|
||||
} // for z
|
||||
}
|
||||
@ -1375,7 +1375,7 @@ eMonsterType cFinishGenPassiveMobs::GetRandomMob(cChunkDesc & a_ChunkDesc)
|
||||
return mtInvalidType;
|
||||
}
|
||||
|
||||
int RandMob = (m_Noise.IntNoise2DInt(chunkX - chunkZ + 2, chunkX + 5) / 7) % ListOfSpawnables.size();
|
||||
size_t RandMob = static_cast<size_t>((m_Noise.IntNoise2DInt(chunkX - chunkZ + 2, chunkX + 5) / 7)) % ListOfSpawnables.size();
|
||||
auto MobIter = ListOfSpawnables.begin();
|
||||
std::advance(MobIter, RandMob);
|
||||
|
||||
|
@ -64,13 +64,13 @@ cGridStructGen::cGridStructGen(
|
||||
LOG("Grid Size cannot be zero, setting to 1");
|
||||
m_GridSizeZ = 1;
|
||||
}
|
||||
size_t NumStructuresPerQuery = (size_t)(((m_MaxStructureSizeX + m_MaxOffsetX) / m_GridSizeX + 1) * ((m_MaxStructureSizeZ + m_MaxOffsetZ) / m_GridSizeZ + 1));
|
||||
size_t NumStructuresPerQuery = static_cast<size_t>(((m_MaxStructureSizeX + m_MaxOffsetX) / m_GridSizeX + 1) * ((m_MaxStructureSizeZ + m_MaxOffsetZ) / m_GridSizeZ + 1));
|
||||
if (NumStructuresPerQuery > m_MaxCacheSize)
|
||||
{
|
||||
m_MaxCacheSize = NumStructuresPerQuery * 4;
|
||||
LOGINFO(
|
||||
"cGridStructGen: The cache size is too small (%u), increasing the cache size to %u to avoid inefficiency.",
|
||||
(unsigned)a_MaxCacheSize, (unsigned)m_MaxCacheSize
|
||||
static_cast<unsigned>(a_MaxCacheSize), static_cast<unsigned>(m_MaxCacheSize)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
@ -58,7 +58,7 @@ public:
|
||||
virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override
|
||||
{
|
||||
int heights[cChunkDef::Width * cChunkDef::Width];
|
||||
m_Gen->GetInts(a_ChunkX * cChunkDef::Width, a_ChunkZ * cChunkDef::Width, cChunkDef::Width, cChunkDef::Width, heights);
|
||||
m_Gen->GetInts(a_ChunkX * cChunkDef::Width, a_ChunkZ * cChunkDef::Width, static_cast<size_t>(cChunkDef::Width), static_cast<size_t>(cChunkDef::Width), heights);
|
||||
for (size_t i = 0; i < ARRAYCOUNT(heights); i++)
|
||||
{
|
||||
a_HeightMap[i] = static_cast<HEIGHTTYPE>(std::max(std::min(60 + heights[i], cChunkDef::Height - 60), 40));
|
||||
@ -92,7 +92,7 @@ void cHeiGenFlat::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap
|
||||
|
||||
void cHeiGenFlat::InitializeHeightGen(cIniFile & a_IniFile)
|
||||
{
|
||||
m_Height = a_IniFile.GetValueSetI("Generator", "FlatHeight", m_Height);
|
||||
m_Height = static_cast<HEIGHTTYPE>(a_IniFile.GetValueSetI("Generator", "FlatHeight", m_Height));
|
||||
}
|
||||
|
||||
|
||||
@ -300,15 +300,7 @@ void cHeiGenClassic::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightM
|
||||
{
|
||||
const float xx = (float)(a_ChunkX * cChunkDef::Width + x);
|
||||
|
||||
int hei = 64 + (int)(GetNoise(xx * 0.05f, zz * 0.05f) * 16);
|
||||
if (hei < 10)
|
||||
{
|
||||
hei = 10;
|
||||
}
|
||||
if (hei > 250)
|
||||
{
|
||||
hei = 250;
|
||||
}
|
||||
HEIGHTTYPE hei = static_cast<HEIGHTTYPE>(Clamp(static_cast<int>(64 + (GetNoise(xx * 0.05f, zz * 0.05f) * 16)), 10, 250));
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, hei);
|
||||
} // for x
|
||||
} // for z
|
||||
@ -366,15 +358,7 @@ void cHeiGenMountains::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::Heigh
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
int idx = IdxZ + x;
|
||||
int hei = 100 - (int)((MountainNoise[idx] - DitchNoise[idx] + PerlinNoise[idx]) * 15);
|
||||
if (hei < 10)
|
||||
{
|
||||
hei = 10;
|
||||
}
|
||||
if (hei > 250)
|
||||
{
|
||||
hei = 250;
|
||||
}
|
||||
HEIGHTTYPE hei = static_cast<HEIGHTTYPE>(Clamp(100 - static_cast<int>((MountainNoise[idx] - DitchNoise[idx] + PerlinNoise[idx]) * 15), 10, 250));
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, hei);
|
||||
} // for x
|
||||
} // for z
|
||||
@ -536,7 +520,7 @@ void cHeiGenBiomal::GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMa
|
||||
{
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, (int)Height[x + 17 * z]);
|
||||
cChunkDef::SetHeight(a_HeightMap, x, z, static_cast<HEIGHTTYPE>(Height[x + 17 * z]));
|
||||
}
|
||||
}
|
||||
//*/
|
||||
@ -817,7 +801,10 @@ protected:
|
||||
case biTaiga: a_Min = 63; a_Max = 75; break;
|
||||
case biTaigaHills: a_Min = 63; a_Max = 90; break;
|
||||
case biTaigaM: a_Min = 63; a_Max = 80; break;
|
||||
default:
|
||||
case biInvalidBiome:
|
||||
case biNumBiomes:
|
||||
case biVariant:
|
||||
case biNumVariantBiomes:
|
||||
{
|
||||
ASSERT(!"Unknown biome");
|
||||
a_Min = 10;
|
||||
|
@ -103,7 +103,7 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
int m_Height;
|
||||
HEIGHTTYPE m_Height;
|
||||
|
||||
// cTerrainHeightGen overrides:
|
||||
virtual void GenHeightMap(int a_ChunkX, int a_ChunkZ, cChunkDef::HeightMap & a_HeightMap) override;
|
||||
|
@ -542,7 +542,7 @@ cMineShaft * cMineShaftCorridor::CreateAndFit(
|
||||
{
|
||||
cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
|
||||
BoundingBox.p2.y += 3;
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
|
||||
int NumSegments = 2 + (rnd) % (MAX_SEGMENTS - 1); // 2 .. MAX_SEGMENTS
|
||||
switch (a_Direction)
|
||||
{
|
||||
@ -564,14 +564,14 @@ cMineShaft * cMineShaftCorridor::CreateAndFit(
|
||||
|
||||
void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;
|
||||
int Outerrnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 7;
|
||||
// Prefer the same height, but allow for up to one block height displacement:
|
||||
int Height = m_BoundingBox.p1.y + ((rnd % 4) + ((rnd >> 3) % 3)) / 2;
|
||||
int OuterHeight = m_BoundingBox.p1.y + ((Outerrnd % 4) + ((Outerrnd >> 3) % 3)) / 2;
|
||||
switch (m_Direction)
|
||||
{
|
||||
case dirXM:
|
||||
{
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, Height, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x - 1, OuterHeight, m_BoundingBox.p1.z + 1, dirXM, a_Noise, a_RecursionLevel);
|
||||
for (int i = m_NumSegments; i >= 0; i--)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
|
||||
@ -586,7 +586,7 @@ void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
|
||||
|
||||
case dirXP:
|
||||
{
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, Height, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p2.x + 1, OuterHeight, m_BoundingBox.p1.z + 1, dirXP, a_Noise, a_RecursionLevel);
|
||||
for (int i = m_NumSegments; i >= 0; i--)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
|
||||
@ -601,7 +601,7 @@ void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
|
||||
|
||||
case dirZM:
|
||||
{
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, OuterHeight, m_BoundingBox.p1.z - 1, dirZM, a_Noise, a_RecursionLevel);
|
||||
for (int i = m_NumSegments; i >= 0; i--)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
|
||||
@ -616,7 +616,7 @@ void cMineShaftCorridor::AppendBranches(int a_RecursionLevel, cNoise & a_Noise)
|
||||
|
||||
case dirZP:
|
||||
{
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, Height, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
|
||||
m_ParentSystem.AppendBranch(m_BoundingBox.p1.x + 1, OuterHeight, m_BoundingBox.p2.z + 1, dirZP, a_Noise, a_RecursionLevel);
|
||||
for (int i = m_NumSegments; i >= 0; i--)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(m_BoundingBox.p1.x + i + 10, m_BoundingBox.p1.y + a_RecursionLevel, m_BoundingBox.p1.z) / 11;
|
||||
@ -781,7 +781,6 @@ void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
|
||||
|
||||
case dirZM:
|
||||
case dirZP:
|
||||
default:
|
||||
{
|
||||
x = m_BoundingBox.p1.x - BlockX;
|
||||
z = m_BoundingBox.p1.z + m_ChestPosition - BlockZ;
|
||||
@ -796,7 +795,7 @@ void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
|
||||
)
|
||||
{
|
||||
a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);
|
||||
cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z);
|
||||
cChestEntity * ChestEntity = static_cast<cChestEntity *>(a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z));
|
||||
ASSERT((ChestEntity != nullptr) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
|
||||
cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
|
||||
int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);
|
||||
@ -986,7 +985,7 @@ cMineShaft * cMineShaftCrossing::CreateAndFit(
|
||||
)
|
||||
{
|
||||
cCuboid BoundingBox(a_PivotX, a_PivotY - 1, a_PivotZ);
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
|
||||
BoundingBox.p2.y += 3;
|
||||
if ((rnd % 4) < 2)
|
||||
{
|
||||
@ -1127,7 +1126,7 @@ cMineShaft * cMineShaftStaircase::CreateAndFit(
|
||||
cNoise & a_Noise
|
||||
)
|
||||
{
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + (int)a_ParentSystem.m_MineShafts.size(), a_PivotZ) / 7;
|
||||
int rnd = a_Noise.IntNoise3DInt(a_PivotX, a_PivotY + static_cast<int>(a_ParentSystem.m_MineShafts.size()), a_PivotZ) / 7;
|
||||
cCuboid Box;
|
||||
switch (a_Direction)
|
||||
{
|
||||
|
@ -36,7 +36,7 @@ public:
|
||||
int BlockY = 64;
|
||||
|
||||
// Generate pieces:
|
||||
for (int i = 0; m_Pieces.size() < (size_t)(a_MaxDepth * a_MaxDepth / 8 + a_MaxDepth); i++)
|
||||
for (int i = 0; m_Pieces.size() < static_cast<size_t>(a_MaxDepth * a_MaxDepth / 8 + a_MaxDepth); i++)
|
||||
{
|
||||
cBFSPieceGenerator pg(cNetherFortGen::m_PiecePool, a_Seed + i);
|
||||
pg.PlacePieces(a_OriginX, BlockY, a_OriginZ, a_MaxDepth, m_Pieces);
|
||||
@ -55,7 +55,7 @@ public:
|
||||
{
|
||||
for (cPlacedPieces::const_iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
const cPrefab & Prefab = (const cPrefab &)((*itr)->GetPiece());
|
||||
const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
|
||||
Prefab.Draw(a_Chunk, *itr);
|
||||
} // for itr - m_PlacedPieces[]
|
||||
}
|
||||
|
@ -305,7 +305,7 @@ void cNoise3DGenerator::UpdateHeightmap(cChunkDesc & a_ChunkDesc)
|
||||
{
|
||||
for (int x = 0; x < cChunkDef::Width; x++)
|
||||
{
|
||||
for (int y = cChunkDef::Height - 1; y > 0; y--)
|
||||
for (HEIGHTTYPE y = cChunkDef::Height - 1; y > 0; y--)
|
||||
{
|
||||
if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_AIR)
|
||||
{
|
||||
@ -790,7 +790,10 @@ void cBiomalNoise3DComposable::GetBiomeParams(EMCSBiome a_Biome, NOISE_DATATYPE
|
||||
case biTaiga: a_HeightAmp = 0.1f; a_MidPoint = 64; break;
|
||||
case biTaigaM: a_HeightAmp = 0.1f; a_MidPoint = 70; break;
|
||||
case biTaigaHills: a_HeightAmp = 0.075f; a_MidPoint = 68; break;
|
||||
default:
|
||||
case biInvalidBiome:
|
||||
case biNumBiomes:
|
||||
case biVariant:
|
||||
case biNumVariantBiomes:
|
||||
{
|
||||
// Make a crazy terrain so that it stands out
|
||||
a_HeightAmp = 0.001f;
|
||||
|
@ -32,7 +32,7 @@ public:
|
||||
|
||||
|
||||
/** Imprints the piece in the specified chunk. Assumes they intersect. */
|
||||
void ImprintInChunk(cChunkDesc & a_ChunkDesc, const Vector3i & a_Pos, int a_NumCCWRotations)
|
||||
void ImprintInChunk(cChunkDesc & a_ChunkDesc, const Vector3i & a_Pos, int a_NumCCWRotations) const
|
||||
{
|
||||
int BlockX = a_ChunkDesc.GetChunkX() * cChunkDef::Width;
|
||||
int BlockZ = a_ChunkDesc.GetChunkZ() * cChunkDef::Width;
|
||||
@ -227,7 +227,7 @@ void cPOCPieceGenerator::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
continue;
|
||||
}
|
||||
|
||||
((cPOCPiece &)(*itr)->GetPiece()).ImprintInChunk(a_ChunkDesc, Pos, (*itr)->GetNumCCWRotations());
|
||||
(static_cast<const cPOCPiece &>((*itr)->GetPiece())).ImprintInChunk(a_ChunkDesc, Pos, (*itr)->GetNumCCWRotations());
|
||||
} // for itr - m_Pieces[]
|
||||
a_ChunkDesc.UpdateHeightmap();
|
||||
}
|
||||
|
@ -385,7 +385,7 @@ cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, i
|
||||
else
|
||||
{
|
||||
// All pieces returned zero weight, but we need one to start. Choose with equal chance:
|
||||
StartingPiece = StartingPieces[rnd % StartingPieces.size()];
|
||||
StartingPiece = StartingPieces[static_cast<size_t>(rnd) % StartingPieces.size()];
|
||||
}
|
||||
rnd = rnd >> 16;
|
||||
|
||||
@ -394,9 +394,9 @@ cPlacedPiece * cPieceGenerator::PlaceStartingPiece(int a_BlockX, int a_BlockY, i
|
||||
int NumRotations = 1;
|
||||
for (size_t i = 1; i < ARRAYCOUNT(Rotations); i++)
|
||||
{
|
||||
if (StartingPiece->CanRotateCCW((int)i))
|
||||
if (StartingPiece->CanRotateCCW(static_cast<int>(i)))
|
||||
{
|
||||
Rotations[NumRotations] = (int)i;
|
||||
Rotations[NumRotations] = static_cast<int>(i);
|
||||
NumRotations += 1;
|
||||
}
|
||||
}
|
||||
@ -561,7 +561,10 @@ void cPieceGenerator::DebugConnectorPool(const cPieceGenerator::cFreeConnectors
|
||||
{
|
||||
printf(" Connector pool: " SIZE_T_FMT " items\n", a_ConnectorPool.size() - a_NumProcessed);
|
||||
size_t idx = 0;
|
||||
for (cPieceGenerator::cFreeConnectors::const_iterator itr = a_ConnectorPool.begin() + a_NumProcessed, end = a_ConnectorPool.end(); itr != end; ++itr, ++idx)
|
||||
|
||||
typedef cPieceGenerator::cFreeConnectors::difference_type difType;
|
||||
|
||||
for (auto itr = a_ConnectorPool.cbegin() + static_cast<difType>(a_NumProcessed), end = a_ConnectorPool.cend(); itr != end; ++itr, ++idx)
|
||||
{
|
||||
printf(" " SIZE_T_FMT ": {%d, %d, %d}, type %d, direction %s, depth %d\n",
|
||||
idx,
|
||||
@ -672,7 +675,10 @@ void cBFSPieceGenerator::PlacePieces(int a_BlockX, int a_BlockY, int a_BlockZ, i
|
||||
NumProcessed++;
|
||||
if (NumProcessed > 1000)
|
||||
{
|
||||
ConnectorPool.erase(ConnectorPool.begin(), ConnectorPool.begin() + NumProcessed);
|
||||
|
||||
typedef cPieceGenerator::cFreeConnectors::difference_type difType;
|
||||
|
||||
ConnectorPool.erase(ConnectorPool.begin(), ConnectorPool.begin() + static_cast<difType>(NumProcessed));
|
||||
NumProcessed = 0;
|
||||
}
|
||||
}
|
||||
|
@ -348,13 +348,13 @@ void cPrefab::ParseCharMap(CharMap & a_CharMapOut, const char * a_CharMapDef)
|
||||
LOGWARNING("Bad prefab CharMap definition line: \"%s\", skipping.", itr->c_str());
|
||||
continue;
|
||||
}
|
||||
unsigned char Src = (unsigned char)CharDef[0][0];
|
||||
unsigned char Src = static_cast<unsigned char>(CharDef[0][0]);
|
||||
ASSERT(a_CharMapOut[Src].m_BlockMeta == 16); // This letter has not been assigned yet?
|
||||
a_CharMapOut[Src].m_BlockType = (BLOCKTYPE)atoi(CharDef[1].c_str());
|
||||
a_CharMapOut[Src].m_BlockType = static_cast<BLOCKTYPE>(atoi(CharDef[1].c_str()));
|
||||
NIBBLETYPE BlockMeta = 0;
|
||||
if ((NumElements >= 3) && !CharDef[2].empty())
|
||||
{
|
||||
BlockMeta = (NIBBLETYPE)atoi(CharDef[2].c_str());
|
||||
BlockMeta = static_cast<NIBBLETYPE>(atoi(CharDef[2].c_str()));
|
||||
ASSERT((BlockMeta <= 15));
|
||||
}
|
||||
a_CharMapOut[Src].m_BlockMeta = BlockMeta;
|
||||
@ -372,7 +372,7 @@ void cPrefab::ParseBlockImage(const CharMap & a_CharMap, const char * a_BlockIma
|
||||
{
|
||||
for (int z = 0; z < m_Size.z; z++)
|
||||
{
|
||||
const unsigned char * BlockImage = (const unsigned char *)a_BlockImage + y * m_Size.x * m_Size.z + z * m_Size.x;
|
||||
const unsigned char * BlockImage = reinterpret_cast<const unsigned char *>(a_BlockImage + y * m_Size.x * m_Size.z + z * m_Size.x);
|
||||
for (int x = 0; x < m_Size.x; x++)
|
||||
{
|
||||
const sBlockTypeDef & MappedValue = a_CharMap[BlockImage[x]];
|
||||
@ -424,7 +424,7 @@ void cPrefab::ParseConnectors(const char * a_ConnectorsDef)
|
||||
m_Connectors.push_back(cPiece::cConnector(
|
||||
atoi(Coords[0].c_str()), atoi(Coords[1].c_str()), atoi(Coords[2].c_str()), // Connector pos
|
||||
atoi(Defs[0].c_str()), // Connector type
|
||||
(eBlockFace)BlockFace
|
||||
static_cast<eBlockFace>(BlockFace)
|
||||
));
|
||||
} // for itr - Lines[]
|
||||
}
|
||||
|
@ -85,7 +85,7 @@ void cPrefabPiecePool::AddStartingPieceDefs(const cPrefab::sDef * a_StartingPiec
|
||||
|
||||
void cPrefabPiecePool::AddToPerConnectorMap(cPrefab * a_Prefab)
|
||||
{
|
||||
cPiece::cConnectors Connectors = ((const cPiece *)a_Prefab)->GetConnectors();
|
||||
cPiece::cConnectors Connectors = (static_cast<const cPiece *>(a_Prefab))->GetConnectors();
|
||||
for (cPiece::cConnectors::const_iterator itr = Connectors.begin(), end = Connectors.end(); itr != end; ++itr)
|
||||
{
|
||||
m_PiecesByConnector[itr->m_Type].push_back(a_Prefab);
|
||||
@ -122,7 +122,7 @@ cPieces cPrefabPiecePool::GetStartingPieces(void)
|
||||
|
||||
int cPrefabPiecePool::GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const cPiece::cConnector & a_ExistingConnector, const cPiece & a_NewPiece)
|
||||
{
|
||||
return ((const cPrefab &)a_NewPiece).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
|
||||
return (static_cast<const cPrefab &>(a_NewPiece)).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
|
||||
}
|
||||
|
||||
|
||||
@ -131,7 +131,7 @@ int cPrefabPiecePool::GetPieceWeight(const cPlacedPiece & a_PlacedPiece, const c
|
||||
|
||||
int cPrefabPiecePool::GetStartingPieceWeight(const cPiece & a_NewPiece)
|
||||
{
|
||||
return ((const cPrefab &)a_NewPiece).GetDefaultWeight();
|
||||
return (static_cast<const cPrefab &>(a_NewPiece)).GetDefaultWeight();
|
||||
}
|
||||
|
||||
|
||||
|
@ -47,7 +47,7 @@ public:
|
||||
virtual ~cProtIntGen() {}
|
||||
|
||||
/** Generates the array of specified size into a_Values, based on given min coords. */
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) = 0;
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) = 0;
|
||||
};
|
||||
|
||||
|
||||
@ -109,14 +109,14 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int BaseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int BaseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
a_Values[x + a_SizeX * z] = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7) % m_Range;
|
||||
a_Values[x + a_SizeX * z] = (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
|
||||
}
|
||||
} // for z
|
||||
}
|
||||
@ -146,22 +146,22 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int BaseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int BaseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int rnd = (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7);
|
||||
int rnd = (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7);
|
||||
a_Values[x + a_SizeX * z] = ((rnd % 100) < m_Threshold) ? ((rnd / 101) % bgLandOceanMax + 1) : 0;
|
||||
}
|
||||
}
|
||||
|
||||
// If the centerpoint of the world is within the area, set it to bgTemperate, always:
|
||||
if ((a_MinX <= 0) && (a_MinZ <= 0) && (a_MinX + a_SizeX > 0) && (a_MinZ + a_SizeZ > 0))
|
||||
if ((a_MinX <= 0) && (a_MinZ <= 0) && (a_MinX + static_cast<int>(a_SizeX) > 0) && (a_MinZ + static_cast<int>(a_SizeZ) > 0))
|
||||
{
|
||||
a_Values[-a_MinX - a_MinZ * a_SizeX] = bgTemperate;
|
||||
a_Values[static_cast<size_t>(-a_MinX) - static_cast<size_t>(a_MinZ) * a_SizeX] = bgTemperate;
|
||||
}
|
||||
}
|
||||
|
||||
@ -189,13 +189,13 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Get the coords for the lower generator:
|
||||
int lowerMinX = a_MinX >> 1;
|
||||
int lowerMinZ = a_MinZ >> 1;
|
||||
int lowerSizeX = a_SizeX / 2 + 2;
|
||||
int lowerSizeZ = a_SizeZ / 2 + 2;
|
||||
size_t lowerSizeX = a_SizeX / 2 + 2;
|
||||
size_t lowerSizeZ = a_SizeZ / 2 + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
ASSERT(lowerSizeX > 0);
|
||||
ASSERT(lowerSizeZ > 0);
|
||||
@ -203,22 +203,22 @@ public:
|
||||
// Generate the underlying data with half the resolution:
|
||||
int lowerData[m_BufferSize];
|
||||
m_UnderlyingGen->GetInts(lowerMinX, lowerMinZ, lowerSizeX, lowerSizeZ, lowerData);
|
||||
const int lowStepX = (lowerSizeX - 1) * 2;
|
||||
const size_t lowStepX = (lowerSizeX - 1) * 2;
|
||||
int cache[m_BufferSize];
|
||||
|
||||
// Discreet-interpolate the values into twice the size:
|
||||
for (int z = 0; z < lowerSizeZ - 1; ++z)
|
||||
for (size_t z = 0; z < lowerSizeZ - 1; ++z)
|
||||
{
|
||||
int idx = (z * 2) * lowStepX;
|
||||
size_t idx = (z * 2) * lowStepX;
|
||||
int PrevZ0 = lowerData[z * lowerSizeX];
|
||||
int PrevZ1 = lowerData[(z + 1) * lowerSizeX];
|
||||
|
||||
for (int x = 0; x < lowerSizeX - 1; ++x)
|
||||
for (size_t x = 0; x < lowerSizeX - 1; ++x)
|
||||
{
|
||||
int ValX1Z0 = lowerData[x + 1 + z * lowerSizeX];
|
||||
int ValX1Z1 = lowerData[x + 1 + (z + 1) * lowerSizeX];
|
||||
int RndX = (x + lowerMinX) * 2;
|
||||
int RndZ = (z + lowerMinZ) * 2;
|
||||
int RndX = (static_cast<int>(x) + lowerMinX) * 2;
|
||||
int RndZ = (static_cast<int>(z) + lowerMinZ) * 2;
|
||||
cache[idx] = PrevZ0;
|
||||
cache[idx + lowStepX] = super::chooseRandomOne(RndX, RndZ + 1, PrevZ0, PrevZ1);
|
||||
cache[idx + 1] = super::chooseRandomOne(RndX, RndZ - 1, PrevZ0, ValX1Z0);
|
||||
@ -230,7 +230,7 @@ public:
|
||||
}
|
||||
|
||||
// Copy from Cache into a_Values; take into account the even / odd offsets in a_Min:
|
||||
for (int z = 0; z < a_SizeZ; ++z)
|
||||
for (size_t z = 0; z < a_SizeZ; ++z)
|
||||
{
|
||||
memcpy(a_Values + z * a_SizeX, cache + (z + (a_MinZ & 1)) * lowStepX + (a_MinX & 1), a_SizeX * sizeof(int));
|
||||
}
|
||||
@ -259,21 +259,21 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Smooth - for each square check if the surroundings are the same, if so, expand them diagonally.
|
||||
// Also get rid of single-pixel irregularities (A-B-A):
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int NoiseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int NoiseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int val = lowerData[x + 1 + (z + 1) * lowerSizeX];
|
||||
int above = lowerData[x + 1 + z * lowerSizeX];
|
||||
@ -283,7 +283,7 @@ public:
|
||||
|
||||
if ((left == right) && (above == below))
|
||||
{
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 2) == 0)
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 2) == 0)
|
||||
{
|
||||
val = left;
|
||||
}
|
||||
@ -331,21 +331,21 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 1;
|
||||
int lowerSizeZ = a_SizeZ + 1;
|
||||
size_t lowerSizeX = a_SizeX + 1;
|
||||
size_t lowerSizeZ = a_SizeZ + 1;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Average - add all 4 "neighbors" and divide by 4:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idxLower = x + lowerSizeX * z;
|
||||
size_t idxLower = x + lowerSizeX * z;
|
||||
a_Values[x + a_SizeX * z] = (
|
||||
lowerData[idxLower] + lowerData[idxLower + 1] +
|
||||
lowerData[idxLower + lowerSizeX] + lowerData[idxLower + lowerSizeX + 1]
|
||||
@ -375,24 +375,24 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 4;
|
||||
int lowerSizeZ = a_SizeZ + 4;
|
||||
size_t lowerSizeX = a_SizeX + 4;
|
||||
size_t lowerSizeZ = a_SizeZ + 4;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Calculate the weighted average of all 16 "neighbors":
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idxLower1 = x + lowerSizeX * z;
|
||||
int idxLower2 = idxLower1 + lowerSizeX;
|
||||
int idxLower3 = idxLower1 + 2 * lowerSizeX;
|
||||
int idxLower4 = idxLower1 + 3 * lowerSizeX;
|
||||
size_t idxLower1 = x + lowerSizeX * z;
|
||||
size_t idxLower2 = idxLower1 + lowerSizeX;
|
||||
size_t idxLower3 = idxLower1 + 2 * lowerSizeX;
|
||||
size_t idxLower4 = idxLower1 + 3 * lowerSizeX;
|
||||
a_Values[x + a_SizeX * z] = (
|
||||
1 * lowerData[idxLower1] + 2 * lowerData[idxLower1 + 1] + 2 * lowerData[idxLower1 + 2] + 1 * lowerData[idxLower1 + 3] +
|
||||
2 * lowerData[idxLower2] + 32 * lowerData[idxLower2 + 1] + 32 * lowerData[idxLower2 + 2] + 2 * lowerData[idxLower2 + 3] +
|
||||
@ -425,23 +425,23 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 3;
|
||||
int lowerSizeZ = a_SizeZ + 3;
|
||||
size_t lowerSizeX = a_SizeX + 3;
|
||||
size_t lowerSizeZ = a_SizeZ + 3;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Calculate the weighted average the neighbors:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idxLower1 = x + lowerSizeX * z;
|
||||
int idxLower2 = idxLower1 + lowerSizeX;
|
||||
int idxLower3 = idxLower1 + 2 * lowerSizeX;
|
||||
size_t idxLower1 = x + lowerSizeX * z;
|
||||
size_t idxLower2 = idxLower1 + lowerSizeX;
|
||||
size_t idxLower3 = idxLower1 + 2 * lowerSizeX;
|
||||
a_Values[x + a_SizeX * z] = (
|
||||
WeightDiagonal * lowerData[idxLower1] + WeightCardinal * lowerData[idxLower1 + 1] + WeightDiagonal * lowerData[idxLower1 + 2] +
|
||||
WeightCardinal * lowerData[idxLower2] + WeightCenter * lowerData[idxLower2 + 1] + WeightCardinal * lowerData[idxLower2 + 2] +
|
||||
@ -476,20 +476,20 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
|
||||
// Replace random values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int BaseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int BaseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
if (((super::m_Noise.IntNoise2DInt(BaseZ, a_MinX + x) / 13) % 101) < m_ChancePct)
|
||||
if (((super::m_Noise.IntNoise2DInt(BaseZ, a_MinX + static_cast<int>(x)) / 13) % 101) < m_ChancePct)
|
||||
{
|
||||
a_Values[x + a_SizeX * z] = m_Min + (super::m_Noise.IntNoise2DInt(a_MinX + x, BaseZ) / 7) % m_Range;
|
||||
a_Values[x + a_SizeX * z] = m_Min + (super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), BaseZ) / 7) % m_Range;
|
||||
}
|
||||
} // for x
|
||||
} // for z
|
||||
@ -522,18 +522,18 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
|
||||
// Add the random values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int NoiseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int NoiseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int noiseVal = ((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % m_Range) - m_HalfRange;
|
||||
int noiseVal = ((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % m_Range) - m_HalfRange;
|
||||
a_Values[x + z * a_SizeX] += noiseVal;
|
||||
}
|
||||
}
|
||||
@ -564,23 +564,23 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Average random values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int NoiseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int NoiseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idxLower = x + 1 + lowerSizeX * (z + 1);
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 100) > m_AvgChancePct)
|
||||
size_t idxLower = x + 1 + lowerSizeX * (z + 1);
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
|
||||
{
|
||||
// Average the 4 neighbors:
|
||||
a_Values[x + z * a_SizeX] = (
|
||||
@ -621,28 +621,28 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerData[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerData);
|
||||
|
||||
// Average random values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int NoiseZ = a_MinZ + z;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
int NoiseZ = a_MinZ + static_cast<int>(z);
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idxLower = x + 1 + lowerSizeX * (z + 1);
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ) / 7) % 100) > m_AvgChancePct)
|
||||
size_t idxLower = x + 1 + lowerSizeX * (z + 1);
|
||||
if (((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ) / 7) % 100) > m_AvgChancePct)
|
||||
{
|
||||
// Chose a value in between the min and max neighbor:
|
||||
int min = std::min(std::min(lowerData[idxLower - 1], lowerData[idxLower + 1]), std::min(lowerData[idxLower - lowerSizeX], lowerData[idxLower + lowerSizeX]));
|
||||
int max = std::max(std::max(lowerData[idxLower - 1], lowerData[idxLower + 1]), std::max(lowerData[idxLower - lowerSizeX], lowerData[idxLower + lowerSizeX]));
|
||||
a_Values[x + z * a_SizeX] = min + ((super::m_Noise.IntNoise2DInt(a_MinX + x, NoiseZ + 10) / 7) % (max - min + 1));
|
||||
a_Values[x + z * a_SizeX] = min + ((super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), NoiseZ + 10) / 7) % (max - min + 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -675,7 +675,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Map for biome -> its beach:
|
||||
static const int ToBeach[] =
|
||||
@ -723,16 +723,16 @@ public:
|
||||
};
|
||||
|
||||
// Generate the underlying values:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerValues[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);
|
||||
|
||||
// Add beaches between ocean and biomes:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int val = lowerValues[x + 1 + (z + 1) * lowerSizeX];
|
||||
int above = lowerValues[x + 1 + z * lowerSizeX];
|
||||
@ -779,16 +779,16 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
if (a_Values[x + z * a_SizeX] == bgOcean)
|
||||
{
|
||||
int rnd = super::m_Noise.IntNoise2DInt(a_MinX + x, a_MinZ + z) / 7;
|
||||
int rnd = super::m_Noise.IntNoise2DInt(a_MinX + static_cast<int>(x), a_MinZ + static_cast<int>(z)) / 7;
|
||||
if (rnd % 1000 < m_Chance)
|
||||
{
|
||||
a_Values[x + z * a_SizeX] = (rnd / 1003) % bgLandOceanMax;
|
||||
@ -822,19 +822,19 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values)
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values)
|
||||
{
|
||||
// Generate the underlying biome groups:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerValues[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, lowerSizeX, lowerSizeZ, lowerValues);
|
||||
|
||||
// Change the biomes on incompatible edges into an edge biome:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int val = lowerValues[x + 1 + (z + 1) * lowerSizeX];
|
||||
int Above = lowerValues[x + 1 + z * lowerSizeX];
|
||||
@ -920,7 +920,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Define the per-biome-group biomes:
|
||||
static const int oceanBiomes[] =
|
||||
@ -998,16 +998,16 @@ public:
|
||||
|
||||
// Overwrite each biome group with a random biome from that group:
|
||||
// Take care of the bgfRare flag
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int IdxZ = z * a_SizeX;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
size_t IdxZ = z * a_SizeX;
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int val = a_Values[x + IdxZ];
|
||||
const cBiomesInGroups & Biomes = (val > bgfRare) ?
|
||||
rareBiomesInGroups[(val & (bgfRare - 1)) % ARRAYCOUNT(rareBiomesInGroups)] :
|
||||
biomesInGroups[val % ARRAYCOUNT(biomesInGroups)];
|
||||
int rnd = (super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7);
|
||||
biomesInGroups[static_cast<size_t>(val) % ARRAYCOUNT(biomesInGroups)];
|
||||
int rnd = (super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7);
|
||||
a_Values[x + IdxZ] = Biomes.Biomes[rnd % Biomes.Count];
|
||||
}
|
||||
}
|
||||
@ -1050,21 +1050,21 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying values:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
|
||||
// Replace some of the values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int idxZ = z * a_SizeX;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
size_t idxZ = z * a_SizeX;
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idx = x + idxZ;
|
||||
size_t idx = x + idxZ;
|
||||
if (a_Values[idx] == m_From)
|
||||
{
|
||||
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
|
||||
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
|
||||
if (rnd % 1000 < m_Chance)
|
||||
{
|
||||
a_Values[idx] = m_To;
|
||||
@ -1109,7 +1109,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying data:
|
||||
ASSERT(a_SizeX * a_SizeZ <= m_BufferSize);
|
||||
@ -1118,12 +1118,12 @@ public:
|
||||
m_Rivers->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, riverData);
|
||||
|
||||
// Mix the values:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
int idxZ = z * a_SizeX;
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
size_t idxZ = z * a_SizeX;
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int idx = x + idxZ;
|
||||
size_t idx = x + idxZ;
|
||||
if (IsBiomeOcean(a_Values[idx]))
|
||||
{
|
||||
// Oceans are kept without any changes
|
||||
@ -1136,7 +1136,7 @@ public:
|
||||
}
|
||||
|
||||
// There's a river, change the output to a river or a frozen river, based on the original biome:
|
||||
if (IsBiomeVeryCold((EMCSBiome)a_Values[idx]))
|
||||
if (IsBiomeVeryCold(static_cast<EMCSBiome>(a_Values[idx])))
|
||||
{
|
||||
a_Values[idx] = biFrozenRiver;
|
||||
}
|
||||
@ -1173,19 +1173,19 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying data:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerValues[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);
|
||||
|
||||
// Detect the edges:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int Above = lowerValues[x + 1 + z * lowerSizeX];
|
||||
int Below = lowerValues[x + 1 + (z + 2) * lowerSizeX];
|
||||
@ -1231,19 +1231,19 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying data:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerValues[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);
|
||||
|
||||
// Add the mushroom islands:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int val = lowerValues[x + 1 + (z + 1) * lowerSizeX];
|
||||
if (!IsBiomeOcean(val))
|
||||
@ -1278,7 +1278,7 @@ public:
|
||||
// If at least 3 ocean neighbors and the chance is right, change:
|
||||
if (
|
||||
(NumOceanNeighbors >= 3) &&
|
||||
((super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7) % 1000 < m_Chance)
|
||||
((super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7) % 1000 < m_Chance)
|
||||
)
|
||||
{
|
||||
a_Values[x + z * a_SizeX] = m_ToValue;
|
||||
@ -1321,17 +1321,17 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying data:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
|
||||
// Change random pixels to bgOcean:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
|
||||
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
|
||||
if (rnd % 1000 < m_Chance)
|
||||
{
|
||||
a_Values[x + z * a_SizeX] = m_ToValue;
|
||||
@ -1370,20 +1370,20 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying data:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
|
||||
// Change some of the biome groups into rare biome groups:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int rnd = super::m_Noise.IntNoise2DInt(x + a_MinX, z + a_MinZ) / 7;
|
||||
int rnd = super::m_Noise.IntNoise2DInt(static_cast<int>(x) + a_MinX, static_cast<int>(z) + a_MinZ) / 7;
|
||||
if (rnd % 1000 < m_Chance)
|
||||
{
|
||||
int idx = x + a_SizeX * z;
|
||||
size_t idx = x + a_SizeX * z;
|
||||
a_Values[idx] = a_Values[idx] | bgfRare;
|
||||
}
|
||||
}
|
||||
@ -1418,7 +1418,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the base biomes and the alterations:
|
||||
m_BaseBiomes->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
@ -1426,8 +1426,8 @@ public:
|
||||
m_Alterations->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, alterations);
|
||||
|
||||
// Change the biomes into their alternate versions:
|
||||
int len = a_SizeX * a_SizeZ;
|
||||
for (int idx = 0; idx < len; ++idx)
|
||||
size_t len = a_SizeX * a_SizeZ;
|
||||
for (size_t idx = 0; idx < len; ++idx)
|
||||
{
|
||||
if (alterations[idx] == 0)
|
||||
{
|
||||
@ -1482,19 +1482,19 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying biomes:
|
||||
int lowerSizeX = a_SizeX + 2;
|
||||
int lowerSizeZ = a_SizeZ + 2;
|
||||
size_t lowerSizeX = a_SizeX + 2;
|
||||
size_t lowerSizeZ = a_SizeZ + 2;
|
||||
ASSERT(lowerSizeX * lowerSizeZ <= m_BufferSize);
|
||||
int lowerValues[m_BufferSize];
|
||||
m_Underlying->GetInts(a_MinX - 1, a_MinZ - 1, lowerSizeX, lowerSizeZ, lowerValues);
|
||||
|
||||
// Convert incompatible edges into neutral biomes:
|
||||
for (int z = 0; z < a_SizeZ; z++)
|
||||
for (size_t z = 0; z < a_SizeZ; z++)
|
||||
{
|
||||
for (int x = 0; x < a_SizeX; x++)
|
||||
for (size_t x = 0; x < a_SizeX; x++)
|
||||
{
|
||||
int biome = lowerValues[x + 1 + (z + 1) * lowerSizeX];
|
||||
int above = lowerValues[x + 1 + z * lowerSizeX];
|
||||
@ -1642,7 +1642,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, int a_SizeX, int a_SizeZ, int * a_Values) override
|
||||
virtual void GetInts(int a_MinX, int a_MinZ, size_t a_SizeX, size_t a_SizeZ, int *a_Values) override
|
||||
{
|
||||
// Generate the underlying biomes and the alterations:
|
||||
m_Underlying->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, a_Values);
|
||||
@ -1650,8 +1650,8 @@ public:
|
||||
m_Alteration->GetInts(a_MinX, a_MinZ, a_SizeX, a_SizeZ, alterations);
|
||||
|
||||
// Wherever alterations are nonzero, change into alternate biome, if available:
|
||||
int len = a_SizeX * a_SizeZ;
|
||||
for (int idx = 0; idx < len; ++idx)
|
||||
size_t len = a_SizeX * a_SizeZ;
|
||||
for (size_t idx = 0; idx < len; ++idx)
|
||||
{
|
||||
if (alterations[idx] == 0)
|
||||
{
|
||||
|
@ -76,7 +76,7 @@ protected:
|
||||
{
|
||||
for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
cPrefab & Prefab = (cPrefab &)((*itr)->GetPiece());
|
||||
const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
|
||||
Prefab.Draw(a_Chunk, *itr);
|
||||
} // for itr - m_PlacedPieces[]
|
||||
}
|
||||
|
@ -135,17 +135,17 @@ void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_Block
|
||||
|
||||
// Get the base angle in which the ravine "axis" goes:
|
||||
float Angle = (float)(((float)((a_Noise.IntNoise3DInt(20 * a_BlockX, 70 * a_BlockZ, 6000) / 9) % 16384)) / 16384.0 * M_PI);
|
||||
float xc = sin(Angle);
|
||||
float zc = cos(Angle);
|
||||
float xc = sinf(Angle);
|
||||
float zc = cosf(Angle);
|
||||
|
||||
// Calculate the definition points and radii:
|
||||
int MaxRadius = (int)(sqrt(12.0 + ((a_Noise.IntNoise2DInt(61 * a_BlockX, 97 * a_BlockZ) / 13) % a_Size) / 16));
|
||||
int Top = 32 + ((a_Noise.IntNoise2DInt(13 * a_BlockX, 17 * a_BlockZ) / 23) % 32);
|
||||
int Bottom = 5 + ((a_Noise.IntNoise2DInt(17 * a_BlockX, 29 * a_BlockZ) / 13) % 32);
|
||||
int Mid = (Top + Bottom) / 2;
|
||||
int PointX = CenterX - (int)(xc * a_Size / 2);
|
||||
int PointZ = CenterZ - (int)(zc * a_Size / 2);
|
||||
m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, (Mid + Top) / 2, (Mid + Bottom) / 2));
|
||||
int DefinitionPointX = CenterX - (int)(xc * a_Size / 2);
|
||||
int DefinitionPointZ = CenterZ - (int)(zc * a_Size / 2);
|
||||
m_Points.push_back(cRavDefPoint(DefinitionPointX, DefinitionPointZ, 0, (Mid + Top) / 2, (Mid + Bottom) / 2));
|
||||
for (int i = 1; i < NUM_RAVINE_POINTS - 1; i++)
|
||||
{
|
||||
int LineX = CenterX + (int)(xc * a_Size * (i - NUM_RAVINE_POINTS / 2) / NUM_RAVINE_POINTS);
|
||||
@ -160,9 +160,9 @@ void cStructGenRavines::cRavine::GenerateBaseDefPoints(int a_BlockX, int a_Block
|
||||
int ThisBottom = Bottom + ((a_Noise.IntNoise3DInt(19 * a_BlockX, 7 * a_BlockZ, i * 31) / 13) % 8) - 4;
|
||||
m_Points.push_back(cRavDefPoint(PointX, PointZ, Radius, ThisTop, ThisBottom));
|
||||
} // for i - m_Points[]
|
||||
PointX = CenterX + (int)(xc * a_Size / 2);
|
||||
PointZ = CenterZ + (int)(zc * a_Size / 2);
|
||||
m_Points.push_back(cRavDefPoint(PointX, PointZ, 0, Mid, Mid));
|
||||
DefinitionPointX = CenterX + (int)(xc * a_Size / 2);
|
||||
DefinitionPointZ = CenterZ + (int)(zc * a_Size / 2);
|
||||
m_Points.push_back(cRavDefPoint(DefinitionPointX, DefinitionPointZ, 0, Mid, Mid));
|
||||
}
|
||||
|
||||
|
||||
|
@ -21,7 +21,7 @@ class cRoughRavine :
|
||||
|
||||
public:
|
||||
cRoughRavine(
|
||||
int a_Seed, int a_Size,
|
||||
int a_Seed, size_t a_Size,
|
||||
float a_CenterWidth, float a_Roughness,
|
||||
float a_FloorHeightEdge1, float a_FloorHeightEdge2, float a_FloorHeightCenter,
|
||||
float a_CeilingHeightEdge1, float a_CeilingHeightEdge2, float a_CeilingHeightCenter,
|
||||
@ -33,14 +33,14 @@ public:
|
||||
m_Roughness(a_Roughness)
|
||||
{
|
||||
// Create the basic structure - 2 lines meeting at the centerpoint:
|
||||
int Max = 2 * a_Size;
|
||||
int Half = a_Size; // m_DefPoints[Half] will be the centerpoint
|
||||
size_t Max = 2 * a_Size;
|
||||
size_t Half = a_Size; // m_DefPoints[Half] will be the centerpoint
|
||||
m_DefPoints.resize(Max + 1);
|
||||
int rnd = m_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) / 7;
|
||||
float Len = (float)a_Size;
|
||||
float Angle = (float)rnd; // Angle is in radians, will be wrapped in the "sin" and "cos" operations
|
||||
float OfsX = sin(Angle) * Len;
|
||||
float OfsZ = cos(Angle) * Len;
|
||||
float OfsX = sinf(Angle) * Len;
|
||||
float OfsZ = cosf(Angle) * Len;
|
||||
m_DefPoints[0].Set (a_OriginX - OfsX, a_OriginZ - OfsZ, 1, a_CeilingHeightEdge1, a_FloorHeightEdge1);
|
||||
m_DefPoints[Half].Set((float)a_OriginX, (float)a_OriginZ, a_CenterWidth, a_CeilingHeightCenter, a_FloorHeightCenter);
|
||||
m_DefPoints[Max].Set (a_OriginX + OfsX, a_OriginZ + OfsZ, 1, a_CeilingHeightEdge2, a_FloorHeightEdge2);
|
||||
@ -90,7 +90,7 @@ protected:
|
||||
/** Recursively subdivides the line between the points of the specified index.
|
||||
Sets the midpoint to the center of the line plus or minus a random offset, then calls itself for each half
|
||||
of the new line. */
|
||||
void SubdivideLine(int a_Idx1, int a_Idx2)
|
||||
void SubdivideLine(size_t a_Idx1, size_t a_Idx2)
|
||||
{
|
||||
// Calculate the midpoint:
|
||||
const sRavineDefPoint & p1 = m_DefPoints[a_Idx1];
|
||||
@ -114,7 +114,7 @@ protected:
|
||||
MidX -= dz * m_Roughness;
|
||||
MidZ += dx * m_Roughness;
|
||||
}
|
||||
int MidIdx = (a_Idx1 + a_Idx2) / 2;
|
||||
size_t MidIdx = (a_Idx1 + a_Idx2) / 2;
|
||||
m_DefPoints[MidIdx].Set(MidX, MidZ, MidR, MidT, MidB);
|
||||
|
||||
// Recurse the two halves, if they are worth recursing:
|
||||
@ -275,7 +275,7 @@ cRoughRavines::cRoughRavines(
|
||||
cGridStructGen::cStructurePtr cRoughRavines::CreateStructure(int a_GridX, int a_GridZ, int a_OriginX, int a_OriginZ)
|
||||
{
|
||||
// Pick a random value for each of the ravine's parameters:
|
||||
int Size = m_MinSize + (m_Noise.IntNoise2DInt(a_GridX, a_GridZ) / 7) % (m_MaxSize - m_MinSize); // Random int from m_MinSize to m_MaxSize
|
||||
size_t Size = static_cast<size_t>(m_MinSize + (m_Noise.IntNoise2DInt(a_GridX, a_GridZ) / 7) % (m_MaxSize - m_MinSize)); // Random int from m_MinSize to m_MaxSize
|
||||
float CenterWidth = m_Noise.IntNoise2DInRange(a_GridX + 10, a_GridZ, m_MinCenterWidth, m_MaxCenterWidth);
|
||||
float Roughness = m_Noise.IntNoise2DInRange(a_GridX + 20, a_GridZ, m_MinRoughness, m_MaxRoughness);
|
||||
float FloorHeightEdge1 = m_Noise.IntNoise2DInRange(a_GridX + 30, a_GridZ, m_MinFloorHeightEdge, m_MaxFloorHeightEdge);
|
||||
|
@ -72,7 +72,7 @@ void cStructGenTrees::GenFinish(cChunkDesc & a_ChunkDesc)
|
||||
{
|
||||
for (int z = 0; z < cChunkDef::Width; z++)
|
||||
{
|
||||
for (int y = cChunkDef::Height - 1; y >= 0; y--)
|
||||
for (HEIGHTTYPE y = cChunkDef::Height - 1; y >= 0; y--)
|
||||
{
|
||||
if (a_ChunkDesc.GetBlockType(x, y, z) != E_BLOCK_AIR)
|
||||
{
|
||||
@ -304,14 +304,14 @@ void cStructGenOreNests::GenerateOre(int a_ChunkX, int a_ChunkZ, BLOCKTYPE a_Ore
|
||||
|
||||
for (int i = 0; i < a_NumNests; i++)
|
||||
{
|
||||
int rnd = m_Noise.IntNoise3DInt(a_ChunkX + i, a_Seq, a_ChunkZ + 64 * i) / 8;
|
||||
int BaseX = rnd % cChunkDef::Width;
|
||||
rnd /= cChunkDef::Width;
|
||||
int BaseZ = rnd % cChunkDef::Width;
|
||||
rnd /= cChunkDef::Width;
|
||||
int BaseY = rnd % a_MaxHeight;
|
||||
rnd /= a_MaxHeight;
|
||||
int NestSize = a_NestSize + (rnd % (a_NestSize / 4)); // The actual nest size may be up to 1 / 4 larger
|
||||
int Nestrnd = m_Noise.IntNoise3DInt(a_ChunkX + i, a_Seq, a_ChunkZ + 64 * i) / 8;
|
||||
int BaseX = Nestrnd % cChunkDef::Width;
|
||||
Nestrnd /= cChunkDef::Width;
|
||||
int BaseZ = Nestrnd % cChunkDef::Width;
|
||||
Nestrnd /= cChunkDef::Width;
|
||||
int BaseY = Nestrnd % a_MaxHeight;
|
||||
Nestrnd /= a_MaxHeight;
|
||||
int NestSize = a_NestSize + (Nestrnd % (a_NestSize / 4)); // The actual nest size may be up to 1 / 4 larger
|
||||
int Num = 0;
|
||||
while (Num < NestSize)
|
||||
{
|
||||
@ -436,14 +436,14 @@ void cStructGenLakes::CreateLakeImage(int a_ChunkX, int a_ChunkZ, int a_MaxLakeH
|
||||
BLOCKTYPE * BlockTypes = a_Lake.GetBlockTypes();
|
||||
for (int i = 0; i < NumBubbles; i++)
|
||||
{
|
||||
int Rnd = m_Noise.IntNoise3DInt(a_ChunkX, i, a_ChunkZ) / 13;
|
||||
const int BubbleR = 2 + (Rnd & 0x03); // 2 .. 5
|
||||
int BubbleRnd = m_Noise.IntNoise3DInt(a_ChunkX, i, a_ChunkZ) / 13;
|
||||
const int BubbleR = 2 + (BubbleRnd & 0x03); // 2 .. 5
|
||||
const int Range = 16 - 2 * BubbleR;
|
||||
const int BubbleX = BubbleR + (Rnd % Range);
|
||||
const int BubbleX = BubbleR + (BubbleRnd % Range);
|
||||
Rnd >>= 4;
|
||||
const int BubbleY = 4 + (Rnd & 0x01); // 4 .. 5
|
||||
const int BubbleY = 4 + (BubbleRnd & 0x01); // 4 .. 5
|
||||
Rnd >>= 1;
|
||||
const int BubbleZ = BubbleR + (Rnd % Range);
|
||||
const int BubbleZ = BubbleR + (BubbleRnd % Range);
|
||||
const int HalfR = BubbleR / 2; // 1 .. 2
|
||||
const int RSquared = BubbleR * BubbleR;
|
||||
for (int y = -HalfR; y <= HalfR; y++)
|
||||
|
@ -76,7 +76,7 @@ protected:
|
||||
{
|
||||
for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
cPrefab & Prefab = (cPrefab &)((*itr)->GetPiece());
|
||||
const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
|
||||
Prefab.Draw(a_Chunk, *itr);
|
||||
} // for itr - m_PlacedPieces[]
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ inline void PushSomeColumns(int a_BlockX, int a_Height, int a_BlockZ, int a_Colu
|
||||
{
|
||||
int x = a_BlockX + a_Coords[i].x;
|
||||
int z = a_BlockZ + a_Coords[i].z;
|
||||
if (a_Noise.IntNoise3DInt(x + 64 * a_Seq, a_Height + (int)i, z + 64 * a_Seq) <= a_Chance)
|
||||
if (a_Noise.IntNoise3DInt(x + 64 * a_Seq, a_Height + static_cast<int>(i), z + 64 * a_Seq) <= a_Chance)
|
||||
{
|
||||
for (int j = 0; j < a_ColumnHeight; j++)
|
||||
{
|
||||
@ -321,12 +321,12 @@ void GetSmallAppleTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a
|
||||
|
||||
int Random = a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) >> 3;
|
||||
|
||||
int Heights[] = {1, 2, 2, 3} ;
|
||||
int Height = 1 + Heights[Random & 3];
|
||||
HEIGHTTYPE Heights[] = {1, 2, 2, 3} ;
|
||||
HEIGHTTYPE Height = 1 + Heights[Random & 3];
|
||||
Random >>= 2;
|
||||
|
||||
// Pre-alloc so that we don't realloc too often later:
|
||||
a_LogBlocks.reserve(Height + 5);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height + 5));
|
||||
a_OtherBlocks.reserve(ARRAYCOUNT(BigO2) * 2 + ARRAYCOUNT(BigO1) + ARRAYCOUNT(Corners) * 3 + 3 + 5);
|
||||
|
||||
// Trunk:
|
||||
@ -396,8 +396,8 @@ void GetLargeAppleTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a
|
||||
for (int i = 4; i < Height; i++)
|
||||
{
|
||||
// Get a direction for the trunk to go to.
|
||||
Vector3d BranchStartDirection = AvailableDirections[a_Noise.IntNoise3DInt(a_BlockX, a_BlockY + i, a_BlockZ) % ARRAYCOUNT(AvailableDirections)];
|
||||
Vector3d BranchDirection = AvailableDirections[a_Noise.IntNoise3DInt(a_BlockX, a_BlockY / i, a_BlockZ) % ARRAYCOUNT(AvailableDirections)] / 3;
|
||||
Vector3d BranchStartDirection = AvailableDirections[static_cast<size_t>(a_Noise.IntNoise3DInt(a_BlockX, a_BlockY + i, a_BlockZ)) % ARRAYCOUNT(AvailableDirections)];
|
||||
Vector3d BranchDirection = AvailableDirections[static_cast<size_t>(a_Noise.IntNoise3DInt(a_BlockX, a_BlockY / i, a_BlockZ)) % ARRAYCOUNT(AvailableDirections)] / 3;
|
||||
|
||||
int BranchLength = 2 + a_Noise.IntNoise3DInt(a_BlockX * a_Seq, a_BlockY * a_Seq, a_BlockZ * a_Seq) % 3;
|
||||
GetLargeAppleTreeBranch(a_BlockX, a_BlockY + i, a_BlockZ, BranchLength, BranchStartDirection, BranchDirection, a_BlockY + Height, a_Noise, a_LogBlocks);
|
||||
@ -476,10 +476,10 @@ NIBBLETYPE GetLogMetaFromDirection(NIBBLETYPE a_BlockMeta, Vector3d a_Direction)
|
||||
|
||||
void GetBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
|
||||
{
|
||||
int Height = 5 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);
|
||||
HEIGHTTYPE Height = 5 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);
|
||||
|
||||
// Prealloc, so that we don't realloc too often later:
|
||||
a_LogBlocks.reserve(Height);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height));
|
||||
a_OtherBlocks.reserve(80);
|
||||
|
||||
// The entire trunk, out of logs:
|
||||
@ -650,10 +650,10 @@ void GetDarkoakTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_No
|
||||
|
||||
void GetTallBirchTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise, int a_Seq, sSetBlockVector & a_LogBlocks, sSetBlockVector & a_OtherBlocks)
|
||||
{
|
||||
int Height = 9 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);
|
||||
HEIGHTTYPE Height = 9 + (a_Noise.IntNoise3DInt(a_BlockX + 64 * a_Seq, a_BlockY, a_BlockZ) % 3);
|
||||
|
||||
// Prealloc, so that we don't realloc too often later:
|
||||
a_LogBlocks.reserve(Height);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height));
|
||||
a_OtherBlocks.reserve(80);
|
||||
|
||||
// The entire trunk, out of logs:
|
||||
@ -713,12 +713,12 @@ void GetSpruceTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noi
|
||||
// (each of the mod8 remainders has a very different chance of occurrence) - that's why we divide by 8
|
||||
int MyRandom = a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY + 32 * a_Seq, a_BlockZ) / 8;
|
||||
|
||||
static const int sHeights[] = {1, 2, 2, 3};
|
||||
int Height = sHeights[MyRandom & 3];
|
||||
static const HEIGHTTYPE sHeights[] = {1, 2, 2, 3};
|
||||
HEIGHTTYPE Height = sHeights[MyRandom & 3];
|
||||
MyRandom >>= 2;
|
||||
|
||||
// Prealloc, so that we don't realloc too often later:
|
||||
a_LogBlocks.reserve(Height);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height));
|
||||
a_OtherBlocks.reserve(180);
|
||||
|
||||
// Clear trunk blocks:
|
||||
@ -816,8 +816,8 @@ void GetPineTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise
|
||||
}
|
||||
|
||||
// Pre-allocate the vector:
|
||||
a_LogBlocks.reserve(TrunkHeight);
|
||||
a_OtherBlocks.reserve(NumLeavesLayers * 25);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(TrunkHeight));
|
||||
a_OtherBlocks.reserve(static_cast<size_t>(NumLeavesLayers * 25));
|
||||
|
||||
// The entire trunk, out of logs:
|
||||
for (int i = TrunkHeight; i >= 0; --i)
|
||||
@ -843,7 +843,7 @@ void GetPineTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Noise
|
||||
{
|
||||
break;
|
||||
}
|
||||
ASSERT((size_t)LayerSize < ARRAYCOUNT(BigOs));
|
||||
ASSERT(static_cast<size_t>(LayerSize) < ARRAYCOUNT(BigOs));
|
||||
PushCoordBlocks(a_BlockX, h, a_BlockZ, a_OtherBlocks, BigOs[LayerSize].Coords, BigOs[LayerSize].Count, E_BLOCK_LEAVES, E_META_LEAVES_CONIFER);
|
||||
h--;
|
||||
}
|
||||
@ -866,8 +866,8 @@ void GetSwampTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise & a_Nois
|
||||
|
||||
int Height = 3 + (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY, a_BlockZ + 32 * a_Seq) / 8) % 3;
|
||||
|
||||
a_LogBlocks.reserve(Height);
|
||||
a_OtherBlocks.reserve(2 * ARRAYCOUNT(BigO2) + 2 * ARRAYCOUNT(BigO3) + Height * ARRAYCOUNT(Vines) + 20);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height));
|
||||
a_OtherBlocks.reserve(2 * ARRAYCOUNT(BigO2) + 2 * ARRAYCOUNT(BigO3) + static_cast<size_t>(Height) * ARRAYCOUNT(Vines) + 20);
|
||||
|
||||
for (int i = 0; i < Height; i++)
|
||||
{
|
||||
@ -952,8 +952,8 @@ void GetLargeJungleTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise &
|
||||
|
||||
int Height = 24 + (a_Noise.IntNoise3DInt(a_BlockX + 32 * a_Seq, a_BlockY, a_BlockZ + 32 * a_Seq) / 11) % 24;
|
||||
|
||||
a_LogBlocks.reserve(Height * 4);
|
||||
a_OtherBlocks.reserve(2 * ARRAYCOUNT(BigO4) + ARRAYCOUNT(BigO3) + Height * ARRAYCOUNT(Vines) + 50);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height) * 4);
|
||||
a_OtherBlocks.reserve(2 * ARRAYCOUNT(BigO4) + ARRAYCOUNT(BigO3) + static_cast<size_t>(Height) * ARRAYCOUNT(Vines) + 50);
|
||||
|
||||
for (int i = 0; i < Height; i++)
|
||||
{
|
||||
@ -999,12 +999,12 @@ void GetSmallJungleTreeImage(int a_BlockX, int a_BlockY, int a_BlockZ, cNoise &
|
||||
|
||||
int Height = 7 + (a_Noise.IntNoise3DInt(a_BlockX + 5 * a_Seq, a_BlockY, a_BlockZ + 5 * a_Seq) / 5) % 3;
|
||||
|
||||
a_LogBlocks.reserve(Height);
|
||||
a_LogBlocks.reserve(static_cast<size_t>(Height));
|
||||
a_OtherBlocks.reserve(
|
||||
2 * ARRAYCOUNT(BigO3) + // O3 layer, 2x
|
||||
2 * ARRAYCOUNT(BigO2) + // O2 layer, 2x
|
||||
ARRAYCOUNT(BigO1) + 1 + // Plus on the top
|
||||
Height * ARRAYCOUNT(Vines) + // Vines
|
||||
static_cast<size_t>(Height) * ARRAYCOUNT(Vines) + // Vines
|
||||
50 // some safety
|
||||
);
|
||||
|
||||
|
@ -76,7 +76,7 @@ protected:
|
||||
{
|
||||
for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
cPrefab & Prefab = (cPrefab &)((*itr)->GetPiece());
|
||||
const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
|
||||
Prefab.Draw(a_Chunk, *itr);
|
||||
} // for itr - m_PlacedPieces[]
|
||||
}
|
||||
|
@ -93,7 +93,7 @@ public:
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ((const cPrefab &)a_NewPiece).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
|
||||
return static_cast<const cPrefab &>(a_NewPiece).GetPieceWeight(a_PlacedPiece, a_ExistingConnector);
|
||||
}
|
||||
};
|
||||
|
||||
@ -141,7 +141,7 @@ public:
|
||||
|
||||
// If the central piece should be moved to ground, move it, and
|
||||
// check all of its dependents and move those that are strictly connector-driven based on its new Y coord:
|
||||
if (((cPrefab &)m_Pieces[0]->GetPiece()).ShouldMoveToGround())
|
||||
if (static_cast<const cPrefab &>(m_Pieces[0]->GetPiece()).ShouldMoveToGround())
|
||||
{
|
||||
int OrigPosY = m_Pieces[0]->GetCoords().y;
|
||||
PlacePieceOnGround(*m_Pieces[0]);
|
||||
@ -197,7 +197,7 @@ protected:
|
||||
m_HeightGen->GenHeightMap(a_Chunk.GetChunkX(), a_Chunk.GetChunkZ(), HeightMap);
|
||||
for (cPlacedPieces::iterator itr = m_Pieces.begin(), end = m_Pieces.end(); itr != end; ++itr)
|
||||
{
|
||||
cPrefab & Prefab = (cPrefab &)((*itr)->GetPiece());
|
||||
const cPrefab & Prefab = static_cast<const cPrefab &>((*itr)->GetPiece());
|
||||
if ((*itr)->GetPiece().GetSize().y == 1)
|
||||
{
|
||||
// It's a road, special handling (change top terrain blocks to m_RoadBlock)
|
||||
@ -319,7 +319,7 @@ protected:
|
||||
{
|
||||
if (
|
||||
(a_PlacedPieces[i]->GetParent() == Pivot) && // It is a direct dependant of the pivot
|
||||
!((const cPrefab &)a_PlacedPieces[i]->GetPiece()).ShouldMoveToGround() // It attaches strictly by connectors
|
||||
!(static_cast<const cPrefab &>(a_PlacedPieces[i]->GetPiece())).ShouldMoveToGround() // It attaches strictly by connectors
|
||||
)
|
||||
{
|
||||
a_PlacedPieces[i]->MoveToGroundBy(a_HeightDifference);
|
||||
@ -389,8 +389,8 @@ cGridStructGen::cStructurePtr cVillageGen::CreateStructure(int a_GridX, int a_Gr
|
||||
BLOCKTYPE RoadBlock = E_BLOCK_GRAVEL;
|
||||
BLOCKTYPE WaterRoadBlock = E_BLOCK_PLANKS;
|
||||
int rnd = m_Noise.IntNoise2DInt(a_OriginX, a_OriginZ) / 11;
|
||||
cVillagePiecePool * PlainsVillage = g_PlainsVillagePools[rnd % ARRAYCOUNT(g_PlainsVillagePools)];
|
||||
cVillagePiecePool * DesertVillage = g_DesertVillagePools[rnd % ARRAYCOUNT(g_DesertVillagePools)];
|
||||
cVillagePiecePool * PlainsVillage = g_PlainsVillagePools[static_cast<size_t>(rnd) % ARRAYCOUNT(g_PlainsVillagePools)];
|
||||
cVillagePiecePool * DesertVillage = g_DesertVillagePools[static_cast<size_t>(rnd) % ARRAYCOUNT(g_DesertVillagePools)];
|
||||
for (size_t i = 0; i < ARRAYCOUNT(Biomes); i++)
|
||||
{
|
||||
switch (Biomes[i])
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user