mirror of
https://github.com/smartcmd/MinecraftConsoles.git
synced 2026-05-10 15:59:58 +00:00
75eb646bec
The tab player list and teleport menu now show the correct map marker color for each player. The icon is computed using the same hash as the map renderer (getRandomPlayerMapIcon) and stored by player name, bypassing the unreliable small-ID lookup that produced wrong colors on dedicated servers.
944 lines
38 KiB
C++
944 lines
38 KiB
C++
#pragma once
|
|
|
|
using namespace std;
|
|
|
|
#include "Audio/Consoles_SoundEngine.h"
|
|
|
|
#include <xuiapp.h>
|
|
#include ".\Tutorial\TutorialEnum.h"
|
|
|
|
#ifdef _XBOX
|
|
#include ".\XUI\XUI_Helper.h"
|
|
#include ".\XUI\XUI_HelpCredits.h"
|
|
#endif
|
|
#include "UI\UIStructs.h"
|
|
|
|
#include "..\..\Minecraft.World\DisconnectPacket.h"
|
|
#include <xsocialpost.h>
|
|
|
|
#include "..\StringTable.h"
|
|
#include ".\DLC\DLCManager.h"
|
|
#include ".\GameRules\ConsoleGameRulesConstants.h"
|
|
#include ".\GameRules\GameRuleManager.h"
|
|
#include "..\SkinBox.h"
|
|
#include "..\ArchiveFile.h"
|
|
|
|
typedef struct _JoinFromInviteData
|
|
{
|
|
DWORD dwUserIndex; // dwUserIndex
|
|
DWORD dwLocalUsersMask; // dwUserMask
|
|
const INVITE_INFO *pInviteInfo; // pInviteInfo
|
|
}
|
|
JoinFromInviteData;
|
|
|
|
class Player;
|
|
class Inventory;
|
|
class Level;
|
|
class FurnaceTileEntity;
|
|
class Container;
|
|
class DispenserTileEntity;
|
|
class SignTileEntity;
|
|
class BrewingStandTileEntity;
|
|
class CommandBlockEntity;
|
|
class HopperTileEntity;
|
|
class MinecartHopper;
|
|
class EntityHorse;
|
|
class BeaconTileEntity;
|
|
class LocalPlayer;
|
|
class DLCPack;
|
|
class LevelRuleset;
|
|
class ConsoleSchematicFile;
|
|
class Model;
|
|
class ModelPart;
|
|
class StringTable;
|
|
class Merchant;
|
|
|
|
class CMinecraftAudio;
|
|
|
|
class CMinecraftApp
|
|
|
|
#ifdef _XBOX
|
|
: public CXuiModule
|
|
#endif
|
|
{
|
|
private:
|
|
static int s_iHTMLFontSizesA[eHTMLSize_COUNT];
|
|
|
|
public:
|
|
|
|
CMinecraftApp();
|
|
|
|
static const float fSafeZoneX; // 5% of 1280
|
|
static const float fSafeZoneY; // 5% of 720
|
|
|
|
typedef std::vector <PMEMDATA> VMEMFILES;
|
|
typedef std::vector <PNOTIFICATION> VNOTIFICATIONS;
|
|
|
|
// storing skin files
|
|
std::vector <wstring > vSkinNames;
|
|
DLCManager m_dlcManager;
|
|
|
|
// storing credits text from the DLC
|
|
std::vector <wstring > m_vCreditText; // hold the credit text lines so we can avoid duplicating them
|
|
|
|
|
|
// In builds prior to TU5, the size of the GAME_SETTINGS struct was 204 bytes. We added a few new values to the internal struct in TU5, and even though we
|
|
// changed the size of the ucUnused array to be decreased by the size of the values we added, the packing of the struct has introduced some extra
|
|
// padding that resulted in the GAME_SETTINGS struct being 208 bytes. The knock-on effect from this was that all the stats, which come after the game settings
|
|
// in the profile data, we being read offset by 4 bytes. We need to ensure that the GAME_SETTINGS struct does not grow larger than 204 bytes or if we need it
|
|
// to then we need to rebuild the profile data completely and increase the profile version. There should be enough free space to grow larger for a few more updates
|
|
// as long as we take into account the padding issues and check that settings are still stored at the same positions when we read them
|
|
static const int GAME_SETTINGS_PROFILE_DATA_BYTES = 204;
|
|
|
|
#ifdef _EXTENDED_ACHIEVEMENTS
|
|
/* 4J-JEV:
|
|
* We need more space in the profile data because of the new achievements and statistics
|
|
* necessary for the new expanded achievement set.
|
|
*/
|
|
static const int GAME_DEFINED_PROFILE_DATA_BYTES = 2*972; // per user
|
|
#else
|
|
static const int GAME_DEFINED_PROFILE_DATA_BYTES = 972; // per user
|
|
#endif
|
|
unsigned int uiGameDefinedDataChangedBitmask;
|
|
|
|
void DebugPrintf(const char *szFormat, ...);
|
|
void DebugPrintfVerbose(bool bVerbose, const char *szFormat, ...); // Conditional printf
|
|
void DebugPrintf(int user, const char *szFormat, ...);
|
|
|
|
static const int USER_NONE = 0; // disables printf
|
|
static const int USER_GENERAL = 1;
|
|
static const int USER_JV = 2;
|
|
static const int USER_MH = 3;
|
|
static const int USER_PB = 4;
|
|
static const int USER_RR = 5;
|
|
static const int USER_SR = 6;
|
|
static const int USER_UI = 7; // 4J Stu - This also makes it appear on the UI console
|
|
|
|
void HandleButtonPresses();
|
|
bool IntroRunning() { return m_bIntroRunning;}
|
|
void SetIntroRunning(bool bSet) {m_bIntroRunning=bSet;}
|
|
#ifdef _CONTENT_PACKAGE
|
|
#ifndef _FINAL_BUILD
|
|
bool PartnernetPasswordRunning() { return m_bPartnernetPasswordRunning;}
|
|
void SetPartnernetPasswordRunning(bool bSet) {m_bPartnernetPasswordRunning=bSet;}
|
|
#endif
|
|
#endif
|
|
|
|
bool IsAppPaused();
|
|
void SetAppPaused(bool val);
|
|
static int DisplaySavingMessage(LPVOID pParam,const C4JStorage::ESavingMessage eMsg, int iPad);
|
|
bool GetGameStarted() {return m_bGameStarted;}
|
|
void SetGameStarted(bool bVal) { if(bVal) DebugPrintf("SetGameStarted - true\n"); else DebugPrintf("SetGameStarted - false\n"); m_bGameStarted = bVal; m_bIsAppPaused = !bVal;}
|
|
int GetLocalPlayerCount(void);
|
|
bool LoadInventoryMenu(int iPad,shared_ptr<LocalPlayer> player, bool bNavigateBack=false);
|
|
bool LoadCreativeMenu(int iPad,shared_ptr<LocalPlayer> player,bool bNavigateBack=false);
|
|
bool LoadEnchantingMenu(int iPad,shared_ptr<Inventory> inventory, int x, int y, int z, Level *level, const wstring &name);
|
|
bool LoadFurnaceMenu(int iPad,shared_ptr<Inventory> inventory, shared_ptr<FurnaceTileEntity> furnace);
|
|
bool LoadBrewingStandMenu(int iPad,shared_ptr<Inventory> inventory, shared_ptr<BrewingStandTileEntity> brewingStand);
|
|
bool LoadContainerMenu(int iPad,shared_ptr<Container> inventory, shared_ptr<Container> container);
|
|
bool LoadTrapMenu(int iPad,shared_ptr<Container> inventory, shared_ptr<DispenserTileEntity> trap);
|
|
bool LoadCrafting2x2Menu(int iPad,shared_ptr<LocalPlayer> player);
|
|
bool LoadCrafting3x3Menu(int iPad,shared_ptr<LocalPlayer> player, int x, int y, int z);
|
|
bool LoadFireworksMenu(int iPad,shared_ptr<LocalPlayer> player, int x, int y, int z);
|
|
bool LoadSignEntryMenu(int iPad,shared_ptr<SignTileEntity> sign);
|
|
bool LoadRepairingMenu(int iPad,shared_ptr<Inventory> inventory, Level *level, int x, int y, int z);
|
|
bool LoadTradingMenu(int iPad, shared_ptr<Inventory> inventory, shared_ptr<Merchant> trader, Level *level, const wstring &name);
|
|
|
|
bool LoadCommandBlockMenu(int iPad, shared_ptr<CommandBlockEntity> commandBlock) { return false; }
|
|
bool LoadHopperMenu(int iPad ,shared_ptr<Inventory> inventory, shared_ptr<HopperTileEntity> hopper);
|
|
bool LoadHopperMenu(int iPad ,shared_ptr<Inventory> inventory, shared_ptr<MinecartHopper> hopper);
|
|
bool LoadHorseMenu(int iPad ,shared_ptr<Inventory> inventory, shared_ptr<Container> container, shared_ptr<EntityHorse> horse);
|
|
bool LoadBeaconMenu(int iPad ,shared_ptr<Inventory> inventory, shared_ptr<BeaconTileEntity> beacon);
|
|
|
|
bool GetTutorialMode() { return m_bTutorialMode;}
|
|
void SetTutorialMode(bool bSet) {m_bTutorialMode=bSet;}
|
|
|
|
void SetSpecialTutorialCompletionFlag(int iPad, int index);
|
|
|
|
static LPCWSTR GetString(int iID);
|
|
|
|
eGameMode GetGameMode() { return m_eGameMode;}
|
|
void SetGameMode(eGameMode eMode) { m_eGameMode=eMode;}
|
|
|
|
eXuiAction GetGlobalXuiAction() {return m_eGlobalXuiAction;}
|
|
void SetGlobalXuiAction(eXuiAction action) {m_eGlobalXuiAction=action;}
|
|
eXuiAction GetXuiAction(int iPad) {return m_eXuiAction[iPad];}
|
|
void SetAction(int iPad, eXuiAction action, LPVOID param = nullptr);
|
|
void SetTMSAction(int iPad, eTMSAction action) { m_eTMSAction[iPad] = action; }
|
|
eTMSAction GetTMSAction(int iPad) {return m_eTMSAction[iPad];}
|
|
eXuiServerAction GetXuiServerAction(int iPad) {return m_eXuiServerAction[iPad];}
|
|
LPVOID GetXuiServerActionParam(int iPad) {return m_eXuiServerActionParam[iPad];}
|
|
void SetXuiServerAction(int iPad, eXuiServerAction action, LPVOID param = nullptr) {m_eXuiServerAction[iPad]=action; m_eXuiServerActionParam[iPad] = param;}
|
|
eXuiServerAction GetGlobalXuiServerAction() {return m_eGlobalXuiServerAction;}
|
|
void SetGlobalXuiServerAction(eXuiServerAction action) {m_eGlobalXuiServerAction=action;}
|
|
|
|
DisconnectPacket::eDisconnectReason GetDisconnectReason() { return m_disconnectReason; }
|
|
void SetDisconnectReason(DisconnectPacket::eDisconnectReason bVal) { m_disconnectReason = bVal; }
|
|
|
|
bool GetChangingSessionType() { return m_bChangingSessionType; }
|
|
void SetChangingSessionType(bool bVal) { m_bChangingSessionType = bVal; }
|
|
|
|
bool GetReallyChangingSessionType() { return m_bReallyChangingSessionType; }
|
|
void SetReallyChangingSessionType(bool bVal) { m_bReallyChangingSessionType = bVal; }
|
|
|
|
|
|
// 4J Stu - Added so that we can call this when a confirmation box is selected
|
|
static void SetActionConfirmed(LPVOID param);
|
|
void HandleXuiActions(void);
|
|
|
|
// 4J Stu - Functions used for Minecon and other promo work
|
|
bool GetLoadSavesFromFolderEnabled() { return m_bLoadSavesFromFolderEnabled; }
|
|
void SetLoadSavesFromFolderEnabled(bool bVal) { m_bLoadSavesFromFolderEnabled = bVal; }
|
|
|
|
// 4J Stu - Useful for debugging
|
|
bool GetWriteSavesToFolderEnabled() { return m_bWriteSavesToFolderEnabled; }
|
|
void SetWriteSavesToFolderEnabled(bool bVal) { m_bWriteSavesToFolderEnabled = bVal; }
|
|
bool GetMobsDontAttackEnabled() { return m_bMobsDontAttack; }
|
|
void SetMobsDontAttackEnabled(bool bVal) { m_bMobsDontAttack = bVal; }
|
|
bool GetUseDPadForDebug() { return m_bUseDPadForDebug; }
|
|
void SetUseDPadForDebug(bool bVal) { m_bUseDPadForDebug = bVal; }
|
|
bool GetMobsDontTickEnabled() { return m_bMobsDontTick; }
|
|
void SetMobsDontTickEnabled(bool bVal) { m_bMobsDontTick = bVal; }
|
|
|
|
bool GetFreezePlayers() { return m_bFreezePlayers; }
|
|
void SetFreezePlayers(bool bVal) { m_bFreezePlayers = bVal; }
|
|
|
|
// debug -0 show safe area
|
|
void ShowSafeArea(BOOL bShow)
|
|
{
|
|
#ifdef _XBOX
|
|
CXuiSceneBase::ShowSafeArea( bShow );
|
|
#endif
|
|
}
|
|
// 4J-PB - to capture the social post screenshot
|
|
virtual void CaptureScreenshot(int iPad) {};
|
|
//void GetPreviewImage(int iPad,XSOCIAL_PREVIEWIMAGE *preview);
|
|
|
|
void InitGameSettings();
|
|
static int OldProfileVersionCallback(LPVOID pParam,unsigned char *pucData, const unsigned short usVersion, const int iPad);
|
|
|
|
#if ( defined __PS3__ || defined __ORBIS__ || defined _DURANGO || defined __PSVITA__ )
|
|
wstring toStringOptionsStatus(const C4JStorage::eOptionsCallback &eStatus);
|
|
static int DefaultOptionsCallback(LPVOID pParam,C4JStorage::PROFILESETTINGS *pSettings, const int iPad);
|
|
int SetDefaultOptions(C4JStorage::PROFILESETTINGS *pSettings,const int iPad,bool bWriteProfile=true);
|
|
#ifdef __ORBIS__
|
|
static int OptionsDataCallback(LPVOID pParam,int iPad,unsigned short usVersion,C4JStorage::eOptionsCallback eStatus,int iBlocksRequired);
|
|
int GetOptionsBlocksRequired(int iPad);
|
|
#else
|
|
static int OptionsDataCallback(LPVOID pParam,int iPad,unsigned short usVersion,C4JStorage::eOptionsCallback eStatus);
|
|
#endif
|
|
|
|
C4JStorage::eOptionsCallback GetOptionsCallbackStatus(int iPad);
|
|
|
|
void SetOptionsCallbackStatus(int iPad, C4JStorage::eOptionsCallback eStatus);
|
|
#else
|
|
static int DefaultOptionsCallback(LPVOID pParam,C_4JProfile::PROFILESETTINGS *pSettings, const int iPad);
|
|
int SetDefaultOptions(C_4JProfile::PROFILESETTINGS *pSettings,const int iPad);
|
|
#endif
|
|
virtual void SetRichPresenceContext(int iPad, int contextId) = 0;
|
|
|
|
|
|
void SetGameSettings(int iPad,eGameSetting eVal,unsigned char ucVal);
|
|
unsigned char GetGameSettings(int iPad,eGameSetting eVal);
|
|
unsigned char GetGameSettings(eGameSetting eVal); // for the primary pad
|
|
void SetPlayerSkin(int iPad,const wstring &name);
|
|
void SetPlayerSkin(int iPad,DWORD dwSkinId);
|
|
void SetPlayerCape(int iPad,const wstring &name);
|
|
void SetPlayerCape(int iPad,DWORD dwCapeId);
|
|
void SetPlayerFavoriteSkin(int iPad, int iIndex,unsigned int uiSkinID);
|
|
unsigned int GetPlayerFavoriteSkin(int iPad,int iIndex);
|
|
unsigned char GetPlayerFavoriteSkinsPos(int iPad);
|
|
void SetPlayerFavoriteSkinsPos(int iPad,int iPos);
|
|
unsigned int GetPlayerFavoriteSkinsCount(int iPad);
|
|
void ValidateFavoriteSkins(int iPad); // check the DLC is available for the skins
|
|
|
|
// Mash-up pack worlds hide/display
|
|
void HideMashupPackWorld(int iPad, unsigned int iMashupPackID);
|
|
void EnableMashupPackWorlds(int iPad);
|
|
unsigned int GetMashupPackWorlds(int iPad);
|
|
|
|
// Minecraft language select
|
|
void SetMinecraftLanguage(int iPad, unsigned char ucLanguage);
|
|
unsigned char GetMinecraftLanguage(int iPad);
|
|
void SetMinecraftLocale(int iPad, unsigned char ucLanguage);
|
|
unsigned char GetMinecraftLocale(int iPad);
|
|
|
|
// 4J-PB - set a timer when the user navigates the quickselect, so we can bring the opacity back to defaults for a short time
|
|
unsigned int GetOpacityTimer(int iPad) { return m_uiOpacityCountDown[iPad]; }
|
|
void SetOpacityTimer(int iPad) { m_uiOpacityCountDown[iPad]=120; } // 6 seconds
|
|
void TickOpacityTimer(int iPad) { if(m_uiOpacityCountDown[iPad]>0) m_uiOpacityCountDown[iPad]--;}
|
|
|
|
public:
|
|
wstring GetPlayerSkinName(int iPad);
|
|
DWORD GetPlayerSkinId(int iPad);
|
|
wstring GetPlayerCapeName(int iPad);
|
|
DWORD GetPlayerCapeId(int iPad);
|
|
DWORD GetAdditionalModelParts(int iPad);
|
|
void CheckGameSettingsChanged(bool bOverride5MinuteTimer=false, int iPad=XUSER_INDEX_ANY);
|
|
void ApplyGameSettingsChanged(int iPad);
|
|
void ClearGameSettingsChangedFlag(int iPad);
|
|
void ActionGameSettings(int iPad,eGameSetting eVal);
|
|
unsigned int GetGameSettingsDebugMask(int iPad=-1,bool bOverridePlayer=false);
|
|
void SetGameSettingsDebugMask(int iPad, unsigned int uiVal);
|
|
void ActionDebugMask(int iPad, bool bSetAllClear=false);
|
|
|
|
//
|
|
bool IsLocalMultiplayerAvailable();
|
|
|
|
// for sign in change monitoring
|
|
static void SignInChangeCallback(LPVOID pParam, bool bVal, unsigned int uiSignInData);
|
|
static void ClearSignInChangeUsersMask();
|
|
static int SignoutExitWorldThreadProc( void* lpParameter );
|
|
static int PrimaryPlayerSignedOutReturned(void *pParam, int iPad, const C4JStorage::EMessageResult);
|
|
static int EthernetDisconnectReturned(void *pParam, int iPad, const C4JStorage::EMessageResult);
|
|
static void ProfileReadErrorCallback(void *pParam);
|
|
|
|
// FATAL LOAD ERRORS
|
|
virtual void FatalLoadError();
|
|
|
|
// Notifications from the game listener to be passed to the qnet listener
|
|
static void NotificationsCallback(LPVOID pParam,DWORD dwNotification, unsigned int uiParam);
|
|
|
|
// for the ethernet being disconnected
|
|
static void LiveLinkChangeCallback(LPVOID pParam,BOOL bConnected);
|
|
bool GetLiveLinkRequired() {return m_bLiveLinkRequired;}
|
|
void SetLiveLinkRequired(bool required) {m_bLiveLinkRequired=required;}
|
|
|
|
static void UpsellReturnedCallback(LPVOID pParam, eUpsellType type, eUpsellResponse result, int iUserData);
|
|
|
|
#if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
|
|
static int NowDisplayFullVersionPurchase(void *pParam, bool bContinue, int iPad);
|
|
static int MustSignInFullVersionPurchaseReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
#endif
|
|
#if defined __PS3__ || defined __PSVITA__ || defined __ORBIS__
|
|
static int MustSignInFullVersionPurchaseReturnedExitTrial(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
#endif
|
|
|
|
#ifdef _DEBUG_MENUS_ENABLED
|
|
bool DebugSettingsOn() { return m_bDebugOptions;}
|
|
bool DebugArtToolsOn();
|
|
#else
|
|
bool DebugSettingsOn() { return false;}
|
|
bool DebugArtToolsOn() { return false;}
|
|
#endif
|
|
void SetDebugSequence(const char *pchSeq);
|
|
static int DebugInputCallback(LPVOID pParam);
|
|
//bool UploadFileToGlobalStorage(int iQuadrant, C4JStorage::eGlobalStorage eStorageFacility, wstring *wsFile );
|
|
|
|
// Installed DLC
|
|
bool StartInstallDLCProcess(int iPad);
|
|
static int DLCInstalledCallback(LPVOID pParam,int iOfferC,int iPad);
|
|
void HandleDLCLicenseChange();
|
|
static int DLCMountedCallback(LPVOID pParam,int iPad,DWORD dwErr,DWORD dwLicenceMask);
|
|
void MountNextDLC(int iPad);
|
|
//static int DLCReadCallback(LPVOID pParam,C4JStorage::DLC_FILE_DETAILS *pDLCData);
|
|
void HandleDLC(DLCPack *pack);
|
|
bool DLCInstallPending() {return m_bDLCInstallPending;}
|
|
bool DLCInstallProcessCompleted() {return m_bDLCInstallProcessCompleted;}
|
|
void ClearDLCInstalled() { m_bDLCInstallProcessCompleted=false;}
|
|
static int MarketplaceCountsCallback(LPVOID pParam,C4JStorage::DLC_TMS_DETAILS *,int iPad);
|
|
|
|
bool AlreadySeenCreditText(const wstring &wstemp);
|
|
|
|
void ClearNewDLCAvailable(void) { m_bNewDLCAvailable=false; m_bSeenNewDLCTip=true;}
|
|
bool GetNewDLCAvailable() { return m_bNewDLCAvailable;}
|
|
void DisplayNewDLCTipAgain() { m_bSeenNewDLCTip=false;}
|
|
bool DisplayNewDLCTip() { if(!m_bSeenNewDLCTip) { m_bSeenNewDLCTip=true; return true;} else return false;}
|
|
|
|
// functions to store launch data, and to exit the game - required due to possibly being on a demo disc
|
|
virtual void StoreLaunchData();
|
|
virtual void ExitGame();
|
|
|
|
bool isXuidNotch(PlayerUID xuid);
|
|
bool isXuidDeadmau5(PlayerUID xuid);
|
|
|
|
void AddMemoryTextureFile(const wstring &wName, PBYTE pbData, DWORD dwBytes);
|
|
void RemoveMemoryTextureFile(const wstring &wName);
|
|
void GetMemFileDetails(const wstring &wName,PBYTE *ppbData,DWORD *pdwBytes);
|
|
bool IsFileInMemoryTextures(const wstring &wName);
|
|
|
|
// Texture Pack Data files (icon, banner, comparison shot & text)
|
|
void AddMemoryTPDFile(int iConfig,PBYTE pbData,DWORD dwBytes);
|
|
void RemoveMemoryTPDFile(int iConfig);
|
|
bool IsFileInTPD(int iConfig);
|
|
void GetTPD(int iConfig,PBYTE *ppbData,DWORD *pdwBytes);
|
|
int GetTPDSize() {return m_MEM_TPD.size();}
|
|
#ifndef __PS3__
|
|
int GetTPConfigVal(WCHAR *pwchDataFile);
|
|
#endif
|
|
|
|
bool DefaultCapeExists();
|
|
//void InstallDefaultCape(); // attempt to install the default cape once per game launch
|
|
|
|
// invites
|
|
//void ProcessInvite(JoinFromInviteData *pJoinData);
|
|
void ProcessInvite(DWORD dwUserIndex, DWORD dwLocalUsersMask, const INVITE_INFO * pInviteInfo);
|
|
|
|
// Add credits for DLC installed
|
|
void AddCreditText(LPCWSTR lpStr);
|
|
|
|
private:
|
|
PlayerUID m_xuidNotch;
|
|
#ifdef _DURANGO
|
|
unordered_map<PlayerUID, PBYTE, PlayerUID::Hash> m_GTS_Files;
|
|
#else
|
|
unordered_map<PlayerUID, PBYTE> m_GTS_Files;
|
|
#endif
|
|
|
|
// for storing memory textures - player skin
|
|
unordered_map<wstring, PMEMDATA> m_MEM_Files;
|
|
// for storing texture pack data files
|
|
unordered_map<int, PMEMDATA> m_MEM_TPD;
|
|
CRITICAL_SECTION csMemFilesLock; // For locking access to the above map
|
|
CRITICAL_SECTION csMemTPDLock; // For locking access to the above map
|
|
|
|
VNOTIFICATIONS m_vNotifications;
|
|
|
|
public:
|
|
// launch data
|
|
BYTE* m_pLaunchData;
|
|
DWORD m_dwLaunchDataSize;
|
|
|
|
public:
|
|
// BAN LIST
|
|
void AddLevelToBannedLevelList(int iPad,PlayerUID xuid, char *pszLevelName, bool bWriteToTMS);
|
|
bool IsInBannedLevelList(int iPad, PlayerUID xuid, char *pszLevelName);
|
|
void RemoveLevelFromBannedLevelList(int iPad, PlayerUID xuid, char *pszLevelName);
|
|
void InvalidateBannedList(int iPad);
|
|
void SetUniqueMapName(char *pszUniqueMapName);
|
|
char *GetUniqueMapName(void);
|
|
#ifdef _XBOX_ONE
|
|
void AddLevelToBannedLevelList(int iPad, PBANNEDLISTDATA pBannedListData, bool bWriteToTMS);
|
|
#endif
|
|
|
|
|
|
public:
|
|
bool GetResourcesLoaded() {return m_bResourcesLoaded;}
|
|
void SetResourcesLoaded(bool bVal) {m_bResourcesLoaded=bVal;}
|
|
|
|
public:
|
|
bool m_bGameStarted;
|
|
bool m_bIntroRunning;
|
|
bool m_bTutorialMode;
|
|
bool m_bIsAppPaused;
|
|
|
|
bool m_bChangingSessionType;
|
|
bool m_bReallyChangingSessionType;
|
|
|
|
bool m_bDisplayFullVersionPurchase; // for after signing in during the trial, and trying to unlock full version on an upsell
|
|
|
|
void loadMediaArchive();
|
|
void loadStringTable();
|
|
|
|
protected:
|
|
ArchiveFile *m_mediaArchive;
|
|
StringTable *m_stringTable;
|
|
|
|
public:
|
|
int getArchiveFileSize(const wstring &filename);
|
|
bool hasArchiveFile(const wstring &filename);
|
|
byteArray getArchiveFile(const wstring &filename);
|
|
|
|
private:
|
|
|
|
static int BannedLevelDialogReturned(void *pParam,int iPad,const C4JStorage::EMessageResult);
|
|
static int TexturePackDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
|
|
VBANNEDLIST *m_vBannedListA[XUSER_MAX_COUNT];
|
|
|
|
void HandleButtonPresses(int iPad);
|
|
|
|
bool m_bResourcesLoaded;
|
|
|
|
// Global string table for this application.
|
|
//CXuiStringTable StringTable;
|
|
|
|
|
|
// Container scene for some menu
|
|
|
|
// CXuiScene debugContainerScene;
|
|
|
|
|
|
//bool m_bSplitScreenEnabled;
|
|
|
|
|
|
#ifdef _CONTENT_PACKAGE
|
|
#ifndef _FINAL_BUILD
|
|
bool m_bPartnernetPasswordRunning;
|
|
#endif
|
|
#endif
|
|
|
|
eGameMode m_eGameMode; // single or multiplayer
|
|
|
|
static unsigned int m_uiLastSignInData;
|
|
|
|
// We've got sizeof(GAME_SETTINGS) bytes reserved at the start of the gamedefined data per player for settings
|
|
GAME_SETTINGS *GameSettingsA[XUSER_MAX_COUNT];
|
|
|
|
// For promo work
|
|
bool m_bLoadSavesFromFolderEnabled;
|
|
|
|
// For debugging
|
|
bool m_bWriteSavesToFolderEnabled;
|
|
bool m_bMobsDontAttack;
|
|
bool m_bUseDPadForDebug;
|
|
bool m_bMobsDontTick;
|
|
bool m_bFreezePlayers;
|
|
|
|
// 4J : WESTY : For taking screen shots.
|
|
//bool m_bInterfaceRenderingOff;
|
|
//bool m_bHandRenderingOff;
|
|
|
|
DisconnectPacket::eDisconnectReason m_disconnectReason;
|
|
|
|
public:
|
|
virtual void RunFrame() {};
|
|
|
|
|
|
|
|
static const DWORD m_dwOfferID = 0x00000001;
|
|
|
|
// timer
|
|
void InitTime();
|
|
void UpdateTime();
|
|
|
|
// trial timer
|
|
void SetTrialTimerStart(void);
|
|
float getTrialTimer(void);
|
|
|
|
// notifications from the game for qnet
|
|
VNOTIFICATIONS *GetNotifications() {return &m_vNotifications;}
|
|
|
|
private:
|
|
|
|
|
|
// To avoid problems with threads being kicked off from xuis that alter things that may be in progress within the run_middle,
|
|
// we'll action these at the end of the game loop
|
|
eXuiAction m_eXuiAction[XUSER_MAX_COUNT];
|
|
eTMSAction m_eTMSAction[XUSER_MAX_COUNT];
|
|
LPVOID m_eXuiActionParam[XUSER_MAX_COUNT];
|
|
eXuiAction m_eGlobalXuiAction;
|
|
eXuiServerAction m_eXuiServerAction[XUSER_MAX_COUNT];
|
|
LPVOID m_eXuiServerActionParam[XUSER_MAX_COUNT];
|
|
eXuiServerAction m_eGlobalXuiServerAction;
|
|
|
|
bool m_bLiveLinkRequired;
|
|
|
|
static int UnlockFullExitReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int UnlockFullSaveReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int UnlockFullInviteReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int TrialOverReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int ExitAndJoinFromInvite(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int ExitAndJoinFromInviteSaveDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int ExitAndJoinFromInviteAndSaveReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int ExitAndJoinFromInviteDeclineSaveReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int FatalErrorDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
static int WarningTrialTexturePackReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
|
|
JoinFromInviteData m_InviteData;
|
|
bool m_bDebugOptions; // toggle debug things on or off
|
|
|
|
// Trial timer
|
|
float m_fTrialTimerStart,mfTrialPausedTime;
|
|
typedef struct TimeInfo
|
|
{
|
|
LARGE_INTEGER qwTime;
|
|
LARGE_INTEGER qwAppTime;
|
|
|
|
float fAppTime;
|
|
float fElapsedTime;
|
|
float fSecsPerTick;
|
|
} TIMEINFO;
|
|
|
|
TimeInfo m_Time;
|
|
|
|
protected:
|
|
static const int MAX_TIPS_GAMETIP = 50;
|
|
static const int MAX_TIPS_TRIVIATIP = 20;
|
|
static TIPSTRUCT m_GameTipA[MAX_TIPS_GAMETIP];
|
|
static TIPSTRUCT m_TriviaTipA[MAX_TIPS_TRIVIATIP];
|
|
static Random *TipRandom;
|
|
public:
|
|
void InitialiseTips();
|
|
UINT GetNextTip();
|
|
int GetHTMLColour(eMinecraftColour colour);
|
|
int GetHTMLColor(eMinecraftColour colour) { return GetHTMLColour(colour); }
|
|
int GetHTMLFontSize(EHTMLFontSize size);
|
|
wstring FormatHTMLString(int iPad, const wstring &desc, int shadowColour = 0xFFFFFFFF);
|
|
wstring GetActionReplacement(int iPad, unsigned char ucAction);
|
|
wstring GetVKReplacement(unsigned int uiVKey);
|
|
wstring GetIconReplacement(unsigned int uiIcon);
|
|
|
|
float getAppTime() { return m_Time.fAppTime; }
|
|
void UpdateTrialPausedTimer() { mfTrialPausedTime+= m_Time.fElapsedTime;}
|
|
|
|
static int RemoteSaveThreadProc( void* lpParameter );
|
|
static void ExitGameFromRemoteSave( LPVOID lpParameter );
|
|
static int ExitGameFromRemoteSaveDialogReturned(void *pParam,int iPad,C4JStorage::EMessageResult result);
|
|
private:
|
|
UINT m_TipIDA[MAX_TIPS_GAMETIP+MAX_TIPS_TRIVIATIP];
|
|
UINT m_uiCurrentTip;
|
|
static int TipsSortFunction(const void* a, const void* b);
|
|
|
|
// XML
|
|
public:
|
|
|
|
// Hold a vector of terrain feature positions
|
|
void AddTerrainFeaturePosition(_eTerrainFeatureType,int,int);
|
|
void ClearTerrainFeaturePosition();
|
|
_eTerrainFeatureType IsTerrainFeature(int x,int z);
|
|
bool GetTerrainFeaturePosition(_eTerrainFeatureType eType, int *pX, int *pZ);
|
|
std::vector <FEATURE_DATA *> m_vTerrainFeatures;
|
|
|
|
static HRESULT RegisterMojangData(WCHAR *, PlayerUID, WCHAR *, WCHAR *);
|
|
MOJANG_DATA *GetMojangDataForXuid(PlayerUID xuid);
|
|
static HRESULT RegisterConfigValues(WCHAR *pType, int iValue);
|
|
|
|
#if defined(__PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
|
|
HRESULT RegisterDLCData(char *pchDLCName, unsigned int uiSortIndex, char *pchImageURL);
|
|
bool GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,ULONGLONG *pullVal);
|
|
DLC_INFO *GetDLCInfoForTrialOfferID(ULONGLONG ullOfferID_Trial);
|
|
DLC_INFO *GetDLCInfoForFullOfferID(ULONGLONG ullOfferID_Full);
|
|
#elif defined(_XBOX_ONE)
|
|
static HRESULT RegisterDLCData(eDLCContentType, WCHAR *, WCHAR *, WCHAR *, WCHAR *, int, unsigned int);
|
|
//bool GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,WCHAR *pwchProductId);
|
|
bool GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,wstring &wsProductId);
|
|
DLC_INFO *GetDLCInfoForFullOfferID(WCHAR *pwchProductId);
|
|
DLC_INFO *GetDLCInfoForProductName(WCHAR *pwchProductName);
|
|
#else
|
|
static HRESULT RegisterDLCData(WCHAR *, WCHAR *, int, uint64_t, uint64_t, WCHAR *, unsigned int, int, WCHAR *pDataFile);
|
|
bool GetDLCFullOfferIDForSkinID(const wstring &FirstSkin,ULONGLONG *pullVal);
|
|
DLC_INFO *GetDLCInfoForTrialOfferID(ULONGLONG ullOfferID_Trial);
|
|
DLC_INFO *GetDLCInfoForFullOfferID(ULONGLONG ullOfferID_Full);
|
|
#endif
|
|
|
|
unsigned int GetDLCCreditsCount();
|
|
SCreditTextItemDef * GetDLCCredits(int iIndex);
|
|
|
|
// TMS
|
|
void ReadDLCFileFromTMS(int iPad,eTMSAction action, bool bCallback=false);
|
|
void ReadXuidsFileFromTMS(int iPad,eTMSAction action,bool bCallback=false);
|
|
|
|
// images for save thumbnail/social post
|
|
virtual void CaptureSaveThumbnail() =0;
|
|
virtual void GetSaveThumbnail(PBYTE*,DWORD*)=0;
|
|
virtual void ReleaseSaveThumbnail()=0;
|
|
virtual void GetScreenshot(int iPad,PBYTE *pbData,DWORD *pdwSize)=0;
|
|
|
|
virtual void ReadBannedList(int iPad, eTMSAction action=static_cast<eTMSAction>(0), bool bCallback=false)=0;
|
|
|
|
private:
|
|
|
|
std::vector <SCreditTextItemDef *> vDLCCredits;
|
|
|
|
#if defined(__PS3__) || defined(__ORBIS__) || defined (__PSVITA__)
|
|
static unordered_map<PlayerUID,MOJANG_DATA *, PlayerUID::Hash > MojangData;
|
|
static unordered_map<int, char * > DLCTextures_PackID; // for mash-up packs & texture packs
|
|
static unordered_map<string,DLC_INFO * > DLCInfo;
|
|
static unordered_map<wstring, ULONGLONG > DLCInfo_SkinName; // skin name, full offer id
|
|
#elif defined(_DURANGO)
|
|
static unordered_map<PlayerUID,MOJANG_DATA *, PlayerUID::Hash > MojangData;
|
|
static unordered_map<int, wstring > DLCTextures_PackID; // for mash-up packs & texture packs
|
|
//static unordered_map<wstring,DLC_INFO * > DLCInfo_Trial; // full offerid, dlc_info
|
|
static unordered_map<wstring,DLC_INFO * > DLCInfo_Full; // full offerid, dlc_info
|
|
static unordered_map<wstring, wstring > DLCInfo_SkinName; // skin name, full offer id
|
|
#else
|
|
static unordered_map<PlayerUID,MOJANG_DATA * > MojangData;
|
|
static unordered_map<int, ULONGLONG > DLCTextures_PackID; // for mash-up packs & texture packs
|
|
static unordered_map<ULONGLONG,DLC_INFO * > DLCInfo_Trial; // full offerid, dlc_info
|
|
static unordered_map<ULONGLONG,DLC_INFO * > DLCInfo_Full; // full offerid, dlc_info
|
|
static unordered_map<wstring, ULONGLONG > DLCInfo_SkinName; // skin name, full offer id
|
|
#endif
|
|
// bool m_bRead_TMS_XUIDS_XML; // track whether we have already read the TMS xuids.xml file
|
|
// bool m_bRead_TMS_DLCINFO_XML; // track whether we have already read the TMS DLC.xml file
|
|
|
|
bool m_bDefaultCapeInstallAttempted; // have we attempted to install the default cape from tms
|
|
|
|
//bool m_bwasHidingGui; // 4J Stu - Removed 1.8.2 bug fix (TU6) as not needed
|
|
bool m_bDLCInstallProcessCompleted;
|
|
bool m_bDLCInstallPending;
|
|
int m_iTotalDLC;
|
|
int m_iTotalDLCInstalled;
|
|
|
|
public:
|
|
// 4J Stu - We need to be able to detect when a guest player signs in or out causing other guest players to change their xuid
|
|
// The simplest way to do this is to check if their guest number has changed, so store the last known one here
|
|
// 4J Stu - Now storing the whole XUSER_SIGNIN_INFO so we can detect xuid changes
|
|
XUSER_SIGNIN_INFO m_currentSigninInfo[XUSER_MAX_COUNT];
|
|
|
|
//void OverrideFontRenderer(bool set, bool immediate = true);
|
|
// void ToggleFontRenderer() { OverrideFontRenderer(!m_bFontRendererOverridden,false); }
|
|
BANNEDLIST BannedListA[XUSER_MAX_COUNT];
|
|
|
|
private:
|
|
// XUI_FontRenderer *m_fontRenderer;
|
|
// bool m_bFontRendererOverridden;
|
|
// bool m_bOverrideFontRenderer;
|
|
|
|
|
|
bool m_bRead_BannedListA[XUSER_MAX_COUNT];
|
|
char m_pszUniqueMapName[14];
|
|
bool m_BanListCheck[XUSER_MAX_COUNT];
|
|
|
|
public:
|
|
void SetBanListCheck(int iPad,bool bVal) {m_BanListCheck[iPad]=bVal;}
|
|
bool GetBanListCheck(int iPad) { return m_BanListCheck[iPad];}
|
|
// AUTOSAVE
|
|
public:
|
|
void SetAutosaveTimerTime(void);
|
|
bool AutosaveDue(void);
|
|
unsigned int SecondsToAutosave();
|
|
private:
|
|
unsigned int m_uiAutosaveTimer;
|
|
unsigned int m_uiOpacityCountDown[XUSER_MAX_COUNT];
|
|
|
|
// DLC
|
|
bool m_bNewDLCAvailable;
|
|
bool m_bSeenNewDLCTip;
|
|
|
|
// Host options
|
|
private:
|
|
unsigned int m_uiGameHostSettings;
|
|
static unsigned char m_szPNG[8];
|
|
|
|
#ifdef _LARGE_WORLDS
|
|
unsigned int m_GameNewWorldSize;
|
|
bool m_bGameNewWorldSizeUseMoat;
|
|
unsigned int m_GameNewHellScale;
|
|
#endif
|
|
unsigned int FromBigEndian(unsigned int uiValue);
|
|
|
|
public:
|
|
|
|
|
|
void SetGameHostOption(eGameHostOption eVal,unsigned int uiVal);
|
|
void SetGameHostOption(unsigned int &uiHostSettings, eGameHostOption eVal,unsigned int uiVal);
|
|
unsigned int GetGameHostOption(eGameHostOption eVal);
|
|
unsigned int GetGameHostOption(unsigned int uiHostSettings, eGameHostOption eVal);
|
|
|
|
#ifdef _LARGE_WORLDS
|
|
void SetGameNewWorldSize(unsigned int newSize, bool useMoat) { m_GameNewWorldSize = newSize; m_bGameNewWorldSizeUseMoat = useMoat; }
|
|
unsigned int GetGameNewWorldSize() { return m_GameNewWorldSize; }
|
|
unsigned int GetGameNewWorldSizeUseMoat() { return m_bGameNewWorldSizeUseMoat; }
|
|
void SetGameNewHellScale(unsigned int newScale) { m_GameNewHellScale = newScale; }
|
|
unsigned int GetGameNewHellScale() { return m_GameNewHellScale; }
|
|
#endif
|
|
void SetResetNether(bool bResetNether) {m_bResetNether=bResetNether;}
|
|
bool GetResetNether() {return m_bResetNether;}
|
|
bool CanRecordStatsAndAchievements();
|
|
|
|
// World seed from png image
|
|
void GetImageTextData(PBYTE pbImageData, DWORD dwImageBytes,unsigned char *pszSeed,unsigned int &uiHostOptions,bool &bHostOptionsRead,DWORD &uiTexturePack);
|
|
unsigned int CreateImageTextData(PBYTE bTextMetadata, int64_t seed, bool hasSeed, unsigned int uiHostOptions, unsigned int uiTexturePackId);
|
|
|
|
// Game rules
|
|
GameRuleManager m_gameRules;
|
|
|
|
public:
|
|
void processSchematics(LevelChunk *levelChunk);
|
|
void processSchematicsLighting(LevelChunk *levelChunk);
|
|
void loadDefaultGameRules();
|
|
vector<LevelGenerationOptions *> *getLevelGenerators() { return m_gameRules.getLevelGenerators(); }
|
|
void setLevelGenerationOptions(LevelGenerationOptions *levelGen);
|
|
LevelRuleset *getGameRuleDefinitions() { return m_gameRules.getGameRuleDefinitions(); }
|
|
LevelGenerationOptions *getLevelGenerationOptions() { return m_gameRules.getLevelGenerationOptions(); }
|
|
LPCWSTR GetGameRulesString(const wstring &key);
|
|
|
|
private:
|
|
BYTE m_playerColours[MINECRAFT_NET_MAX_PLAYERS]; // An array of QNet small-id's
|
|
unsigned int m_playerGamePrivileges[MINECRAFT_NET_MAX_PLAYERS];
|
|
struct PlayerMapIconEntry { wchar_t name[32]; char icon; };
|
|
PlayerMapIconEntry m_playerMapIcons[MINECRAFT_NET_MAX_PLAYERS];
|
|
|
|
public:
|
|
void UpdatePlayerInfo(BYTE networkSmallId, SHORT playerColourIndex, unsigned int playerGamePrivileges);
|
|
short GetPlayerColour(BYTE networkSmallId);
|
|
void SetPlayerMapIcon(const wchar_t* name, char icon);
|
|
char GetPlayerMapIconByName(const wchar_t* name);
|
|
unsigned int GetPlayerPrivileges(BYTE networkSmallId);
|
|
|
|
wstring getEntityName(eINSTANCEOF type);
|
|
|
|
|
|
|
|
unsigned int AddDLCRequest(eDLCMarketplaceType eContentType, bool bPromote=false);
|
|
bool RetrieveNextDLCContent();
|
|
bool CheckTMSDLCCanStop();
|
|
static int DLCOffersReturned(void *pParam, int iOfferC, DWORD dwType, int iPad);
|
|
DWORD GetDLCContentType(eDLCContentType eType) { return m_dwContentTypeA[eType];}
|
|
eDLCContentType Find_eDLCContentType(DWORD dwType);
|
|
int GetDLCOffersCount() { return m_iDLCOfferC;}
|
|
bool DLCContentRetrieved(eDLCMarketplaceType eType);
|
|
void TickDLCOffersRetrieved();
|
|
void ClearAndResetDLCDownloadQueue();
|
|
bool RetrieveNextTMSPPContent();
|
|
void TickTMSPPFilesRetrieved();
|
|
void ClearTMSPPFilesRetrieved();
|
|
unsigned int AddTMSPPFileTypeRequest(eDLCContentType eType, bool bPromote=false);
|
|
int GetDLCInfoTexturesOffersCount();
|
|
#if defined( __PS3__) || defined(__ORBIS__) || defined(__PSVITA__)
|
|
DLC_INFO *GetDLCInfo(int iIndex);
|
|
DLC_INFO *GetDLCInfo(char *);
|
|
DLC_INFO *GetDLCInfoFromTPackID(int iTPID);
|
|
bool GetDLCNameForPackID(const int iPackID,char **ppchKeyID);
|
|
char * GetDLCInfoTextures(int iIndex);
|
|
int GetDLCInfoCount();
|
|
#else
|
|
|
|
#ifdef _XBOX_ONE
|
|
static int TMSPPFileReturned(LPVOID pParam,int iPad,int iUserData,LPVOID, WCHAR *wchFilename);
|
|
unordered_map<wstring,DLC_INFO * > *GetDLCInfo();
|
|
#else
|
|
static int TMSPPFileReturned(LPVOID pParam,int iPad,int iUserData,C4JStorage::PTMSPP_FILEDATA pFileData, LPCSTR szFilename);
|
|
#endif
|
|
DLC_INFO *GetDLCInfoTrialOffer(int iIndex);
|
|
DLC_INFO *GetDLCInfoFullOffer(int iIndex);
|
|
|
|
int GetDLCInfoTrialOffersCount();
|
|
int GetDLCInfoFullOffersCount();
|
|
#ifdef _XBOX_ONE
|
|
bool GetDLCFullOfferIDForPackID(const int iPackID,wstring &wsProductId);
|
|
wstring GetDLCInfoTexturesFullOffer(int iIndex);
|
|
|
|
#else
|
|
bool GetDLCFullOfferIDForPackID(const int iPackID,ULONGLONG *pullVal);
|
|
ULONGLONG GetDLCInfoTexturesFullOffer(int iIndex);
|
|
#endif
|
|
#endif
|
|
|
|
void SetCorruptSaveDeleted(bool bVal) {m_bCorruptSaveDeleted=bVal;}
|
|
bool GetCorruptSaveDeleted(void) {return m_bCorruptSaveDeleted;}
|
|
|
|
void EnterSaveNotificationSection();
|
|
void LeaveSaveNotificationSection();
|
|
private:
|
|
CRITICAL_SECTION m_saveNotificationCriticalSection;
|
|
int m_saveNotificationDepth;
|
|
// Download Status
|
|
|
|
//Request current_download;
|
|
vector<DLCRequest *> m_DLCDownloadQueue;
|
|
vector<TMSPPRequest *> m_TMSPPDownloadQueue;
|
|
static DWORD m_dwContentTypeA[e_Marketplace_MAX];
|
|
int m_iDLCOfferC;
|
|
bool m_bAllDLCContentRetrieved;
|
|
bool m_bAllTMSContentRetrieved;
|
|
bool m_bTickTMSDLCFiles;
|
|
CRITICAL_SECTION csDLCDownloadQueue;
|
|
CRITICAL_SECTION csTMSPPDownloadQueue;
|
|
CRITICAL_SECTION csAdditionalModelParts;
|
|
CRITICAL_SECTION csAdditionalSkinBoxes;
|
|
CRITICAL_SECTION csAnimOverrideBitmask;
|
|
bool m_bCorruptSaveDeleted;
|
|
|
|
DWORD m_dwAdditionalModelParts[XUSER_MAX_COUNT];
|
|
|
|
BYTE *m_pBannedListFileBuffer;
|
|
DWORD m_dwBannedListFileSize;
|
|
|
|
public:
|
|
DWORD m_dwDLCFileSize;
|
|
BYTE *m_pDLCFileBuffer;
|
|
|
|
// static int CallbackReadXuidsFileFromTMS(LPVOID lpParam, WCHAR *wchFilename, int iPad, bool bResult, int iAction);
|
|
// static int CallbackDLCFileFromTMS(LPVOID lpParam, WCHAR *wchFilename, int iPad, bool bResult, int iAction);
|
|
// static int CallbackBannedListFileFromTMS(LPVOID lpParam, WCHAR *wchFilename, int iPad, bool bResult, int iAction);
|
|
|
|
// Storing additional model parts per skin texture
|
|
void SetAdditionalSkinBoxes(DWORD dwSkinID, SKIN_BOX *SkinBoxA, DWORD dwSkinBoxC);
|
|
vector<ModelPart *> * SetAdditionalSkinBoxes(DWORD dwSkinID, vector<SKIN_BOX *> *pvSkinBoxA);
|
|
vector<ModelPart *> *GetAdditionalModelParts(DWORD dwSkinID);
|
|
vector<SKIN_BOX *> *GetAdditionalSkinBoxes(DWORD dwSkinID);
|
|
void SetAnimOverrideBitmask(DWORD dwSkinID,unsigned int uiAnimOverrideBitmask);
|
|
unsigned int GetAnimOverrideBitmask(DWORD dwSkinID);
|
|
|
|
static DWORD getSkinIdFromPath(const wstring &skin);
|
|
static wstring getSkinPathFromId(DWORD skinId);
|
|
|
|
virtual int LoadLocalTMSFile(WCHAR *wchTMSFile)=0;
|
|
virtual int LoadLocalTMSFile(WCHAR *wchTMSFile, eFileExtensionType eExt)=0;
|
|
virtual void FreeLocalTMSFiles(eTMSFileType eType)=0;
|
|
virtual int GetLocalTMSFileIndex(WCHAR *wchTMSFile,bool bFilenameIncludesExtension,eFileExtensionType eEXT)=0;
|
|
|
|
virtual bool GetTMSGlobalFileListRead() { return true;}
|
|
virtual bool GetTMSDLCInfoRead() { return true;}
|
|
virtual bool GetTMSXUIDsFileRead() { return true;}
|
|
|
|
bool GetBanListRead(int iPad) { return m_bRead_BannedListA[iPad];}
|
|
void SetBanListRead(int iPad,bool bVal) { m_bRead_BannedListA[iPad]=bVal;}
|
|
void ClearBanList(int iPad) { BannedListA[iPad].pBannedList=nullptr;BannedListA[iPad].dwBytes=0;}
|
|
|
|
DWORD GetRequiredTexturePackID() {return m_dwRequiredTexturePackID;}
|
|
void SetRequiredTexturePackID(DWORD dwID) {m_dwRequiredTexturePackID=dwID;}
|
|
|
|
virtual void GetFileFromTPD(eTPDFileType eType,PBYTE pbData,DWORD dwBytes,PBYTE *ppbData,DWORD *pdwBytes ) {*ppbData = nullptr; *pdwBytes = 0;}
|
|
|
|
//XTITLE_DEPLOYMENT_TYPE getDeploymentType() { return m_titleDeploymentType; }
|
|
|
|
private:
|
|
// vector of additional skin model parts, indexed by the skin texture id
|
|
unordered_map<DWORD, vector<ModelPart *> *> m_AdditionalModelParts;
|
|
unordered_map<DWORD, vector<SKIN_BOX *> *> m_AdditionalSkinBoxes;
|
|
unordered_map<DWORD, unsigned int> m_AnimOverrides;
|
|
|
|
|
|
bool m_bResetNether;
|
|
DWORD m_dwRequiredTexturePackID;
|
|
#ifdef _XBOX_ONE
|
|
vector <PBYTE> m_vTMSPPData;
|
|
#endif
|
|
|
|
#if ( defined __PS3__ || defined __ORBIS__ || defined _DURANGO || defined __PSVITA__)
|
|
C4JStorage::eOptionsCallback m_eOptionsStatusA[XUSER_MAX_COUNT];
|
|
|
|
#ifdef __ORBIS__
|
|
int m_eOptionsBlocksRequiredA[XUSER_MAX_COUNT];
|
|
#endif
|
|
#endif
|
|
|
|
|
|
// 4J-PB - language and locale functions
|
|
public:
|
|
|
|
void LocaleAndLanguageInit();
|
|
void getLocale(vector<wstring> &vecWstrLocales);
|
|
DWORD get_eMCLang(WCHAR *pwchLocale);
|
|
DWORD get_xcLang(WCHAR *pwchLocale);
|
|
|
|
void SetTickTMSDLCFiles(bool bVal);
|
|
|
|
wstring getFilePath(DWORD packId, wstring filename, bool bAddDataFolder, wstring mountPoint = L"TPACK:");
|
|
|
|
private:
|
|
unordered_map<int, wstring>m_localeA;
|
|
unordered_map<wstring, int>m_eMCLangA;
|
|
unordered_map<wstring, int>m_xcLangA;
|
|
wstring getRootPath(DWORD packId, bool allowOverride, bool bAddDataFolder, wstring mountPoint);
|
|
public:
|
|
|
|
#ifdef _XBOX
|
|
// bool m_bTransferSavesToXboxOne;
|
|
// unsigned int m_uiTransferSlotC;
|
|
|
|
#elif defined (__PS3__)
|
|
|
|
#elif defined _DURANGO
|
|
|
|
#elif defined _WINDOWS64
|
|
//CMinecraftAudio audio;
|
|
#else // PS4
|
|
|
|
#endif
|
|
|
|
#ifdef _XBOX_ONE
|
|
public:
|
|
void SetReachedMainMenu();
|
|
bool HasReachedMainMenu();
|
|
private:
|
|
bool m_hasReachedMainMenu;
|
|
#endif
|
|
};
|
|
|
|
//singleton
|
|
//extern CMinecraftApp app;
|