2012-02-08 07:36:54 -05:00
2011-10-03 14:41:19 -04:00
# pragma once
# ifndef _WIN32
2012-02-13 16:47:03 -05:00
# include "BlockID.h"
2011-10-03 14:41:19 -04:00
# else
2012-02-13 16:47:03 -05:00
enum ENUM_ITEM_ID ;
2011-10-03 14:41:19 -04:00
# endif
2011-12-23 18:58:54 -05:00
# define MAX_PLAYERS 65535
2011-12-26 15:57:12 -05:00
# include "cSimulatorManager.h"
2012-02-08 07:36:54 -05:00
# include "MersenneTwister.h"
2012-02-13 16:47:03 -05:00
# include "cChunkMap.h"
# include "WorldStorage.h"
# include "cChunkGenerator.h"
2012-03-01 10:18:59 -05:00
# include "Vector3i.h"
2012-03-14 16:56:09 -04:00
# include "Vector3f.h"
2012-03-05 11:41:57 -05:00
# include "ChunkSender.h"
2012-03-07 08:36:30 -05:00
# include "Defines.h"
2012-05-25 03:18:52 -04:00
# include "LightingThread.h"
2012-06-06 16:18:50 -04:00
# include "cItem.h"
2011-12-26 15:57:12 -05:00
2012-01-29 14:28:19 -05:00
2011-11-07 21:02:13 -05:00
class cPacket ;
2011-11-08 20:31:19 -05:00
class cRedstone ;
2011-12-28 16:00:35 -05:00
class cFireSimulator ;
2011-10-03 14:41:19 -04:00
class cWaterSimulator ;
2011-11-06 04:23:20 -05:00
class cLavaSimulator ;
2011-12-26 15:57:12 -05:00
class cSandSimulator ;
2012-03-01 10:18:59 -05:00
class cRedstoneSimulator ;
2011-10-03 14:41:19 -04:00
class cItem ;
class cPlayer ;
class cClientHandle ;
class cEntity ;
class cBlockEntity ;
2012-02-13 16:47:03 -05:00
class cWorldGenerator ; // The generator that actually generates the chunks for a single world
class cChunkGenerator ; // The thread responsible for generating chunks
typedef std : : list < cPlayer * > cPlayerList ;
2012-02-16 08:42:35 -05:00
typedef cItemCallback < cPlayer > cPlayerListCallback ;
2012-02-16 12:20:28 -05:00
typedef cItemCallback < cEntity > cEntityCallback ;
2012-02-13 16:47:03 -05:00
2011-12-26 15:57:12 -05:00
2012-03-24 07:14:34 -04:00
class cWorld //tolua_export
2011-10-03 14:41:19 -04:00
{ //tolua_export
public :
2011-11-08 20:31:19 -05:00
2012-03-16 11:48:40 -04:00
OBSOLETE static cWorld * GetWorld ( ) ;
2011-10-03 14:41:19 -04:00
// Return time in seconds
inline static float GetTime ( ) //tolua_export
{
return m_Time ;
}
2012-03-07 08:36:30 -05:00
long long GetWorldTime ( void ) const { return m_WorldTime ; } //tolua_export
2011-10-26 16:52:19 -04:00
2012-03-07 08:36:30 -05:00
eGameMode GetGameMode ( void ) const { return m_GameMode ; } //tolua_export
2011-10-26 16:52:19 -04:00
2011-10-03 14:41:19 -04:00
void SetWorldTime ( long long a_WorldTime ) { m_WorldTime = a_WorldTime ; } //tolua_export
2012-02-18 12:53:22 -05:00
int GetHeight ( int a_X , int a_Z ) ; //tolua_export
2011-10-03 14:41:19 -04:00
2011-11-07 21:02:13 -05:00
void Broadcast ( const cPacket & a_Packet , cClientHandle * a_Exclude = 0 ) ;
2012-02-28 03:10:51 -05:00
void BroadcastToChunk ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , const cPacket & a_Packet , cClientHandle * a_Exclude = NULL ) ;
2012-02-16 08:42:35 -05:00
void BroadcastToChunkOfBlock ( int a_X , int a_Y , int a_Z , cPacket * a_Packet , cClientHandle * a_Exclude = NULL ) ;
2012-03-14 16:56:09 -04:00
void MarkChunkDirty ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
void MarkChunkSaving ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
void MarkChunkSaved ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
2012-05-25 03:18:52 -04:00
/** Sets the chunk data as either loaded from the storage or generated.
a_BlockLight and a_BlockSkyLight are optional , if not present , chunk will be marked as unlighted .
a_BiomeMap is optional , if not present , biomes will be calculated by the generator
a_HeightMap is optional , if not present , will be calculated .
If a_MarkDirty is set , the chunk is set as dirty ( used after generating )
*/
void SetChunkData (
2012-03-14 16:56:09 -04:00
int a_ChunkX , int a_ChunkY , int a_ChunkZ ,
2012-05-25 03:18:52 -04:00
const BLOCKTYPE * a_BlockTypes ,
const NIBBLETYPE * a_BlockMeta ,
const NIBBLETYPE * a_BlockLight ,
const NIBBLETYPE * a_BlockSkyLight ,
2012-03-14 16:56:09 -04:00
const cChunkDef : : HeightMap * a_HeightMap ,
2012-05-25 03:18:52 -04:00
const cChunkDef : : BiomeMap * a_BiomeMap ,
2012-03-14 16:56:09 -04:00
cEntityList & a_Entities ,
2012-05-25 03:18:52 -04:00
cBlockEntityList & a_BlockEntities ,
bool a_MarkDirty
2012-03-14 16:56:09 -04:00
) ;
2012-05-25 03:18:52 -04:00
void ChunkLighted (
int a_ChunkX , int a_ChunkZ ,
const cChunkDef : : BlockNibbles & a_BlockLight ,
const cChunkDef : : BlockNibbles & a_SkyLight
2012-03-14 16:56:09 -04:00
) ;
2012-03-09 08:42:28 -05:00
bool GetChunkData ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , cChunkDataCallback & a_Callback ) ;
2012-03-05 11:41:57 -05:00
/// Gets the chunk's blocks, only the block types
2012-03-14 16:56:09 -04:00
bool GetChunkBlockTypes ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , BLOCKTYPE * a_BlockTypes ) ;
2012-03-05 11:41:57 -05:00
2012-03-14 16:56:09 -04:00
/// Gets the chunk's blockdata, the entire 4 arrays (Types, Meta, Light, SkyLight)
bool GetChunkBlockData ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , BLOCKTYPE * a_BlockData ) ;
2012-03-05 11:41:57 -05:00
2012-02-16 12:45:26 -05:00
bool IsChunkValid ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) const ;
bool HasChunkAnyClients ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) const ;
2012-05-31 16:04:32 -04:00
void UnloadUnusedChunks ( void ) ; // tolua_export
2012-02-20 11:39:00 -05:00
void CollectPickupsByPlayer ( cPlayer * a_Player ) ;
2012-02-16 14:32:31 -05:00
2011-12-23 18:58:54 -05:00
// MOTD
2012-03-07 08:36:30 -05:00
const AString & GetDescription ( void ) const { return m_Description ; } // FIXME: This should not be in cWorld
2011-12-23 18:58:54 -05:00
// Max Players
2012-03-07 08:36:30 -05:00
unsigned int GetMaxPlayers ( void ) const { return m_MaxPlayers ; } //tolua_export
void SetMaxPlayers ( int iMax ) ; //tolua_export
2011-11-07 21:02:13 -05:00
2011-10-03 14:41:19 -04:00
void AddPlayer ( cPlayer * a_Player ) ;
void RemovePlayer ( cPlayer * a_Player ) ;
2012-02-14 14:14:23 -05:00
2012-06-02 05:38:51 -04:00
bool ForEachPlayer ( cPlayerListCallback & a_Callback ) ; // >> EXPORTED IN MANUALBINDINGS <<
2011-10-03 14:41:19 -04:00
unsigned int GetNumPlayers ( ) ; //tolua_export
2012-02-13 16:47:03 -05:00
2012-02-14 16:09:14 -05:00
// TODO: This interface is dangerous - rewrite to DoWithPlayer(playername, action)
2012-03-07 08:36:30 -05:00
cPlayer * GetPlayer ( const char * a_PlayerName ) ; //tolua_export
2012-02-13 16:47:03 -05:00
2012-02-14 16:09:14 -05:00
// TODO: This interface is dangerous - rewrite to DoWithClosestPlayer(pos, sight, action)
2012-02-13 16:47:03 -05:00
cPlayer * FindClosestPlayer ( const Vector3f & a_Pos , float a_SightLimit ) ;
void SendPlayerList ( cPlayer * a_DestPlayer ) ; // Sends playerlist to the player
2011-10-03 14:41:19 -04:00
void AddEntity ( cEntity * a_Entity ) ;
2012-02-20 11:39:00 -05:00
/// Add an entity to the chunk specified; broadcasts the a_SpawnPacket to all clients of that chunk
void AddEntityToChunk ( cEntity * a_Entity , int a_ChunkX , int a_ChunkY , int a_ChunkZ , cPacket * a_SpawnPacket ) ;
/// Removes the entity from the chunk specified
void RemoveEntityFromChunk ( cEntity * a_Entity , int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
/// Moves the entity from its current chunk to the new chunk specified
void MoveEntityToChunk ( cEntity * a_Entity , int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
/// Compares clients of two chunks, calls the callback accordingly
void CompareChunkClients ( int a_ChunkX1 , int a_ChunkY1 , int a_ChunkZ1 , int a_ChunkX2 , int a_ChunkY2 , int a_ChunkZ2 , cClientDiffCallback & a_Callback ) ;
2012-02-21 10:18:02 -05:00
/// Adds client to a chunk, if not already present; returns true if added, false if present
bool AddChunkClient ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , cClientHandle * a_Client ) ;
2012-02-21 11:27:30 -05:00
/// Removes client from the chunk specified
void RemoveChunkClient ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , cClientHandle * a_Client ) ;
2012-03-22 11:53:40 -04:00
/// Removes the client from all chunks it is present in
void RemoveClientFromChunks ( cClientHandle * a_Client ) ;
2012-02-21 10:18:02 -05:00
2012-05-25 03:18:52 -04:00
/// Sends the chunk to the client specified, if the chunk is valid. If not valid, the request is postponed (ChunkSender will send that chunk when it becomes valid+lighted)
2012-03-06 09:52:44 -05:00
void SendChunkTo ( int a_ChunkX , int a_ChunkY , int a_ChunkZ , cClientHandle * a_Client ) ;
/// Removes client from ChunkSender's queue of chunks to be sent
void RemoveClientFromChunkSender ( cClientHandle * a_Client ) ;
2012-02-21 11:27:30 -05:00
/// Touches the chunk, causing it to be loaded or generated
void TouchChunk ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
2012-02-28 05:45:53 -05:00
/// Loads the chunk, if not already loaded. Doesn't generate. Returns true if chunk valid (even if already loaded before)
bool LoadChunk ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
/// Loads the chunks specified. Doesn't report failure, other than chunks being !IsValid()
void LoadChunks ( const cChunkCoordsList & a_Chunks ) ;
2012-02-28 07:11:14 -05:00
/// Marks the chunk as failed-to-load:
void ChunkLoadFailed ( int a_ChunkX , int a_ChunkY , int a_ChunkZ ) ;
2012-03-07 08:36:30 -05:00
void UpdateSign ( int a_X , int a_Y , int a_Z , const AString & a_Line1 , const AString & a_Line2 , const AString & a_Line3 , const AString & a_Line4 ) ; //tolua_export
2011-10-03 14:41:19 -04:00
2012-02-28 05:45:53 -05:00
/// Marks (a_Stay == true) or unmarks (a_Stay == false) chunks as non-unloadable. To be used only by cChunkStay!
void ChunksStay ( const cChunkCoordsList & a_Chunks , bool a_Stay = true ) ;
2012-04-10 07:22:11 -04:00
/// Regenerate the given chunk:
2012-04-11 08:16:13 -04:00
void RegenerateChunk ( int a_ChunkX , int a_ChunkZ ) ; //tolua_export
2012-05-25 03:18:52 -04:00
/// Generates the given chunk, if not already generated
void GenerateChunk ( int a_ChunkX , int a_ChunkZ ) ; //tolua_export
/// Queues a chunk for lighting; a_Callback is called after the chunk is lighted
void QueueLightChunk ( int a_ChunkX , int a_ChunkZ , cChunkCoordCallback * a_Callback = NULL ) ;
bool IsChunkLighted ( int a_ChunkX , int a_ChunkZ ) ;
2012-02-26 11:15:09 -05:00
2012-02-16 12:20:28 -05:00
// TODO: Export to Lua
bool DoWithEntity ( int a_UniqueID , cEntityCallback & a_Callback ) ;
2011-10-03 14:41:19 -04:00
2012-03-07 08:36:30 -05:00
void SetBlock ( int a_X , int a_Y , int a_Z , char a_BlockType , char a_BlockMeta ) ; //tolua_export
void FastSetBlock ( int a_X , int a_Y , int a_Z , char a_BlockType , char a_BlockMeta ) ; //tolua_export
char GetBlock ( int a_X , int a_Y , int a_Z ) ; //tolua_export
char GetBlock ( const Vector3i & a_Pos ) { return GetBlock ( a_Pos . x , a_Pos . y , a_Pos . z ) ; } //tolua_export
char GetBlockMeta ( int a_X , int a_Y , int a_Z ) ; //tolua_export
char GetBlockMeta ( const Vector3i & a_Pos ) { return GetBlockMeta ( a_Pos . x , a_Pos . y , a_Pos . z ) ; } //tolua_export
void SetBlockMeta ( int a_X , int a_Y , int a_Z , char a_MetaData ) ; //tolua_export
2012-03-01 10:18:59 -05:00
void SetBlockMeta ( const Vector3i & a_Pos , char a_MetaData ) { SetBlockMeta ( a_Pos . x , a_Pos . y , a_Pos . z , a_MetaData ) ; } //tolua_export
2012-03-16 11:48:40 -04:00
char GetBlockSkyLight ( int a_X , int a_Y , int a_Z ) ; //tolua_export
2012-05-25 03:18:52 -04:00
// TODO: char GetBlockActualLight(int a_BlockX, int a_BlockY, int a_BlockZ); // tolua_export
2012-06-07 07:57:51 -04:00
void GetBlockTypeMeta ( int a_BlockX , int a_BlockY , int a_BlockZ , char & a_BlockType , unsigned char & a_BlockMeta ) ; // tolua_export
2012-05-25 03:18:52 -04:00
2012-06-06 16:18:50 -04:00
/// Spawns item pickups for each item in the list. May compress pickups if too many entities:
void SpawnItemPickups ( const cItems & a_Pickups , double a_BlockX , double a_BlockY , double a_BlockZ , double a_FlyAwaySpeed = 1.0 ) ;
/// Spawns item pickups for each item in the list. May compress pickups if too many entities. All pickups get the speed specified:
void SpawnItemPickups ( const cItems & a_Pickups , double a_BlockX , double a_BlockY , double a_BlockZ , double a_SpeedX , double a_SpeedY , double a_SpeedZ ) ;
2012-05-25 03:18:52 -04:00
/// Replaces world blocks with a_Blocks, if they are of type a_FilterBlockType
void ReplaceBlocks ( const sSetBlockVector & a_Blocks , BLOCKTYPE a_FilterBlockType ) ;
/// Retrieves block types of the specified blocks. If a chunk is not loaded, doesn't modify the block. Returns true if all blocks were read.
bool GetBlocks ( sSetBlockVector & a_Blocks , bool a_ContinueOnFailure ) ;
2012-06-06 16:18:50 -04:00
bool DigBlock ( int a_X , int a_Y , int a_Z ) ; //tolua_export
void SendBlockTo ( int a_X , int a_Y , int a_Z , cPlayer * a_Player ) ; //tolua_export
2011-10-03 14:41:19 -04:00
2012-03-07 08:36:30 -05:00
const double & GetSpawnX ( ) { return m_SpawnX ; } //tolua_export
const double & GetSpawnY ( ) ; //tolua_export
const double & GetSpawnZ ( ) { return m_SpawnZ ; } //tolua_export
2011-10-03 14:41:19 -04:00
2011-12-26 15:57:12 -05:00
inline cSimulatorManager * GetSimulatorManager ( ) { return m_SimulatorManager ; }
inline cWaterSimulator * GetWaterSimulator ( ) { return m_WaterSimulator ; }
inline cLavaSimulator * GetLavaSimulator ( ) { return m_LavaSimulator ; }
2011-12-22 16:36:24 -05:00
2012-02-16 08:42:35 -05:00
// TODO: This interface is dangerous! Export as a set of specific action functions for Lua: GetChestItem, GetFurnaceItem, SetFurnaceItem, SetSignLines etc.
2012-02-21 11:27:30 -05:00
// _X 2012_02_21: This function always returns NULL
OBSOLETE cBlockEntity * GetBlockEntity ( int a_X , int a_Y , int a_Z ) ; //tolua_export
2012-02-15 09:22:44 -05:00
/// a_Player is using block entity at [x, y, z], handle that:
void UseBlockEntity ( cPlayer * a_Player , int a_X , int a_Y , int a_Z ) { m_ChunkMap - > UseBlockEntity ( a_Player , a_X , a_Y , a_Z ) ; }
2011-10-03 14:41:19 -04:00
2012-05-25 03:18:52 -04:00
void GrowTree ( int a_BlockX , int a_BlockY , int a_BlockZ ) ; // tolua_export
void GrowTreeFromSapling ( int a_BlockX , int a_BlockY , int a_BlockZ , char a_SaplingMeta ) ; // tolua_export
void GrowTreeByBiome ( int a_BlockX , int a_BlockY , int a_BlockZ ) ; // tolua_export
void GrowTreeImage ( const sSetBlockVector & a_Blocks ) ;
2012-06-07 17:07:21 -04:00
2012-06-09 07:32:34 -04:00
/// Grows the plant at the specified block to its ripe stage (bonemeal used); returns false if the block is not growable.
bool GrowPlant ( int a_BlockX , int a_BlockY , int a_BlockZ ) ; // tolua_export
2012-06-07 17:07:21 -04:00
/// Grows a melon or a pumpkin next to the block specified (assumed to be the stem)
void GrowMelonPumpkin ( int a_BlockX , int a_BlockY , int a_BlockZ , char a_BlockType ) ; // tolua_export
2012-05-25 03:18:52 -04:00
int GetBiomeAt ( int a_BlockX , int a_BlockZ ) ; // tolua_export
2011-10-03 14:41:19 -04:00
2012-03-07 08:36:30 -05:00
const AString & GetName ( void ) const { return m_WorldName ; } //tolua_export
2012-03-12 15:39:41 -04:00
const AString & GetIniFileName ( void ) const { return m_IniFileName ; }
2011-10-03 14:41:19 -04:00
inline static void AbsoluteToRelative ( int & a_X , int & a_Y , int & a_Z , int & a_ChunkX , int & a_ChunkY , int & a_ChunkZ )
{
2012-03-03 15:55:16 -05:00
// TODO: Use floor() instead of weird if statements
// Also fix Y
2012-03-14 16:56:09 -04:00
a_ChunkX = a_X / cChunkDef : : Width ;
if ( a_X < 0 & & a_X % cChunkDef : : Width ! = 0 ) a_ChunkX - - ;
2011-10-03 14:41:19 -04:00
a_ChunkY = 0 ;
2012-03-14 16:56:09 -04:00
a_ChunkZ = a_Z / cChunkDef : : Width ;
if ( a_Z < 0 & & a_Z % cChunkDef : : Width ! = 0 ) a_ChunkZ - - ;
2011-10-03 14:41:19 -04:00
2012-03-14 16:56:09 -04:00
a_X = a_X - a_ChunkX * cChunkDef : : Width ;
a_Y = a_Y - a_ChunkY * cChunkDef : : Height ;
a_Z = a_Z - a_ChunkZ * cChunkDef : : Width ;
2011-10-03 14:41:19 -04:00
}
2012-02-13 16:47:03 -05:00
2011-10-03 14:41:19 -04:00
inline static void BlockToChunk ( int a_X , int a_Y , int a_Z , int & a_ChunkX , int & a_ChunkY , int & a_ChunkZ )
{
2012-03-03 15:55:16 -05:00
// TODO: Use floor() instead of weird if statements
// Also fix Y
2011-10-03 14:41:19 -04:00
( void ) a_Y ; // not unused anymore
2012-03-14 16:56:09 -04:00
a_ChunkX = a_X / cChunkDef : : Width ;
if ( a_X < 0 & & a_X % cChunkDef : : Width ! = 0 ) a_ChunkX - - ;
2011-10-03 14:41:19 -04:00
a_ChunkY = 0 ;
2012-03-14 16:56:09 -04:00
a_ChunkZ = a_Z / cChunkDef : : Width ;
if ( a_Z < 0 & & a_Z % cChunkDef : : Width ! = 0 ) a_ChunkZ - - ;
2011-10-03 14:41:19 -04:00
}
2012-05-25 03:18:52 -04:00
void SaveAllChunks ( void ) ; //tolua_export
/// Returns the number of chunks loaded
2012-02-13 16:47:03 -05:00
int GetNumChunks ( ) const ; //tolua_export
2011-10-03 14:41:19 -04:00
2012-05-25 03:18:52 -04:00
/// Returns the number of chunks loaded and dirty, and in the lighting queue
void GetChunkStats ( int & a_NumValid , int & a_NumDirty , int & a_NumInLightingQueue ) ;
2012-05-30 14:20:38 -04:00
// Various queues length queries (cannot be const, they lock their CS):
inline int GetGeneratorQueueLength ( void ) { return m_Generator . GetQueueLength ( ) ; } // tolua_export
inline int GetLightingQueueLength ( void ) { return m_Lighting . GetQueueLength ( ) ; } // tolua_export
inline int GetStorageLoadQueueLength ( void ) { return m_Storage . GetLoadQueueLength ( ) ; } // tolua_export
inline int GetStorageSaveQueueLength ( void ) { return m_Storage . GetSaveQueueLength ( ) ; } // tolua_export
2012-05-25 03:18:52 -04:00
2011-10-03 14:41:19 -04:00
void Tick ( float a_Dt ) ;
void InitializeSpawn ( ) ;
2011-11-08 20:31:19 -05:00
2012-03-07 08:36:30 -05:00
void CastThunderbolt ( int a_X , int a_Y , int a_Z ) ; //tolua_export
void SetWeather ( eWeather a_Weather ) ; //tolua_export
eWeather GetWeather ( ) { return m_Weather ; } ; //tolua_export
2011-11-09 18:24:51 -05:00
2012-02-13 16:47:03 -05:00
cChunkGenerator & GetGenerator ( void ) { return m_Generator ; }
cWorldStorage & GetStorage ( void ) { return m_Storage ; }
2012-02-18 12:53:22 -05:00
cChunkMap * GetChunkMap ( void ) { return m_ChunkMap ; }
2012-02-08 07:36:54 -05:00
2012-05-29 10:59:43 -04:00
bool IsPlacingItemLegal ( Int16 a_ItemType , int a_BlockX , int a_BlockY , int a_BlockZ ) ;
2012-05-30 17:29:51 -04:00
/// Sets the blockticking to start at the specified block. Only one blocktick per chunk may be set, second call overwrites the first call
void SetNextBlockTick ( int a_BlockX , int a_BlockY , int a_BlockZ ) ; // tolua_export
2011-10-03 14:41:19 -04:00
private :
2012-02-08 07:36:54 -05:00
2011-10-03 14:41:19 -04:00
friend class cRoot ;
2012-05-25 03:18:52 -04:00
2012-02-08 07:36:54 -05:00
// This random generator is to be used only in the Tick() method, and thus only in the World-Tick-thread (MTRand is not exactly thread-safe)
MTRand m_TickRand ;
2011-10-03 14:41:19 -04:00
double m_SpawnX ;
double m_SpawnY ;
double m_SpawnZ ;
float m_LastUnload ;
float m_LastSave ;
static float m_Time ; // Time in seconds
long long m_WorldTime ; // Time in seconds*20, this is sent to clients (is wrapped)
2011-11-06 04:23:20 -05:00
unsigned long long CurrentTick ;
2012-03-07 08:36:30 -05:00
eGameMode m_GameMode ;
2011-10-03 14:41:19 -04:00
float m_WorldTimeFraction ; // When this > 1.f m_WorldTime is incremented by 20
2012-02-13 16:47:03 -05:00
// The cRedstone class simulates redstone and needs access to m_RSList
friend class cRedstone ;
std : : vector < int > m_RSList ;
2012-03-01 10:18:59 -05:00
cSimulatorManager * m_SimulatorManager ;
cSandSimulator * m_SandSimulator ;
cWaterSimulator * m_WaterSimulator ;
cLavaSimulator * m_LavaSimulator ;
cFireSimulator * m_FireSimulator ;
cRedstoneSimulator * m_RedstoneSimulator ;
2011-12-26 15:57:12 -05:00
2012-02-13 16:47:03 -05:00
cCriticalSection m_CSClients ;
cCriticalSection m_CSEntities ;
cCriticalSection m_CSPlayers ;
2011-12-26 18:23:05 -05:00
2012-02-13 16:47:03 -05:00
cWorldStorage m_Storage ;
AString m_Description ;
2011-12-23 18:58:54 -05:00
unsigned int m_MaxPlayers ;
2011-10-03 14:41:19 -04:00
2012-02-13 16:47:03 -05:00
cChunkMap * m_ChunkMap ;
2011-10-03 14:41:19 -04:00
bool m_bAnimals ;
float m_SpawnMonsterTime ;
float m_SpawnMonsterRate ;
2012-03-07 08:36:30 -05:00
eWeather m_Weather ;
2012-02-08 07:36:54 -05:00
2012-02-13 16:47:03 -05:00
cEntityList m_RemoveEntityQueue ;
cEntityList m_AllEntities ;
cClientHandleList m_Clients ;
cPlayerList m_Players ;
2012-02-08 07:36:54 -05:00
2012-02-13 16:47:03 -05:00
cCriticalSection m_CSFastSetBlock ;
2012-02-18 15:10:57 -05:00
sSetBlockList m_FastSetBlockQueue ;
2012-02-13 16:47:03 -05:00
cChunkGenerator m_Generator ;
2012-03-05 11:41:57 -05:00
cChunkSender m_ChunkSender ;
2012-05-25 03:18:52 -04:00
cLightingThread m_Lighting ;
2012-02-13 16:47:03 -05:00
AString m_WorldName ;
2012-03-12 15:39:41 -04:00
AString m_IniFileName ;
2012-04-10 07:22:11 -04:00
2012-02-13 16:47:03 -05:00
cWorld ( const AString & a_WorldName ) ;
~ cWorld ( ) ;
void TickWeather ( float a_Dt ) ; // Handles weather each tick
void TickSpawnMobs ( float a_Dt ) ; // Handles mob spawning each tick
void RemoveEntity ( cEntity * a_Entity ) ;
2011-10-03 14:41:19 -04:00
} ; //tolua_export
2012-02-08 07:36:54 -05:00