Karutoh/MinecraftConsoles
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ca5fde56fed613a8f45767868636e2321b03d3f3
MinecraftConsoles/Minecraft.Client/Common/Tutorial/Tutorial.cpp
daoge b3feddfef3 feat: TU19 (Dec 2014) Features & Content (#155) 
* try to resolve merge conflict

* feat: TU19 (Dec 2014) Features & Content (#32)

* December 2014 files

* Working release build

* Fix compilation issues

* Add sound to Windows64Media

* Add DLC content and force Tutorial DLC

* Revert "Add DLC content and force Tutorial DLC"

This reverts commit 97a4399472.

* Disable broken light packing

* Disable breakpoint during DLC texture map load

Allows DLC loading but the DLC textures are still broken

* Fix post build not working

* ...

* fix vs2022 build

* fix cmake build

---------

Co-authored-by: Loki <lokirautio@gmail.com>
2026-03-03 03:04:10 +08:00

2333 lines
106 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "..\..\..\Minecraft.World\net.minecraft.stats.h"
#include "..\..\LocalPlayer.h"
#include "..\..\..\Minecraft.World\Entity.h"
#include "..\..\..\Minecraft.World\Level.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.entity.player.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.item.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.level.h"
#include "..\..\..\Minecraft.World\net.minecraft.world.level.tile.h"
#include "..\..\MinecraftServer.h"
#include "..\..\Minecraft.h"
#include "..\..\MultiPlayerLocalPlayer.h"
#include "..\..\MultiPlayerLevel.h"
#include "..\..\SurvivalMode.h"
#include "Tutorial.h"
#include "TutorialMessage.h"
#include "TutorialTasks.h"
#include "TutorialConstraints.h"
#include "TutorialHints.h"
vector<int> Tutorial::s_completableTasks;
int Tutorial::m_iTutorialHintDelayTime = 14000;
int Tutorial::m_iTutorialDisplayMessageTime = 7000;
int Tutorial::m_iTutorialMinimumDisplayMessageTime = 2000;
int Tutorial::m_iTutorialExtraReminderTime = 13000;
int Tutorial::m_iTutorialReminderTime = m_iTutorialDisplayMessageTime + m_iTutorialExtraReminderTime;
int Tutorial::m_iTutorialConstraintDelayRemoveTicks = 15;
int Tutorial::m_iTutorialFreezeTimeValue = 8000;
bool Tutorial::PopupMessageDetails::isSameContent(PopupMessageDetails *other)
{
if(other == NULL) return false;
bool textTheSame = (m_messageId == other->m_messageId) && (m_messageString.compare(other->m_messageString) == 0);
bool titleTheSame = (m_titleId == other->m_titleId) && (m_titleString.compare(other->m_titleString) == 0);
bool promptTheSame = (m_promptId == other->m_promptId) && (m_promptString.compare(other->m_promptString) == 0);
return textTheSame && titleTheSame && promptTheSame;
}
void Tutorial::staticCtor()
{
//
/*
*****
*****
THE ORDERING OF THESE SHOULD NOT CHANGE - Although the ordering may not be totally logical due to the order tasks were added, these map
to bits in the profile data in this order. New tasks/hints should be added at the end.
*****
*****
*/
s_completableTasks.push_back( e_Tutorial_State_Inventory_Menu );
s_completableTasks.push_back( e_Tutorial_State_2x2Crafting_Menu );
s_completableTasks.push_back( e_Tutorial_State_3x3Crafting_Menu );
s_completableTasks.push_back( e_Tutorial_State_Furnace_Menu );
s_completableTasks.push_back( e_Tutorial_State_Riding_Minecart );
s_completableTasks.push_back( e_Tutorial_State_Riding_Boat );
s_completableTasks.push_back( e_Tutorial_State_Fishing );
s_completableTasks.push_back( e_Tutorial_State_Bed );
s_completableTasks.push_back( e_Tutorial_State_Container_Menu );
s_completableTasks.push_back( e_Tutorial_State_Trap_Menu );
s_completableTasks.push_back( e_Tutorial_State_Redstone_And_Piston );
s_completableTasks.push_back( e_Tutorial_State_Portal );
s_completableTasks.push_back( e_Tutorial_State_Creative_Inventory_Menu );
s_completableTasks.push_back( e_Tutorial_State_Food_Bar );
s_completableTasks.push_back( e_Tutorial_State_CreativeMode );
s_completableTasks.push_back( e_Tutorial_State_Brewing );
s_completableTasks.push_back( e_Tutorial_State_Brewing_Menu );
s_completableTasks.push_back( e_Tutorial_State_Enchanting );
s_completableTasks.push_back( e_Tutorial_Hint_Hold_To_Mine );
s_completableTasks.push_back( e_Tutorial_Hint_Tool_Damaged );
s_completableTasks.push_back( e_Tutorial_Hint_Swim_Up );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_2 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_3 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_4 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_5 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_6 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_7 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_8 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_9 );
s_completableTasks.push_back( e_Tutorial_Hint_Unused_10 );
s_completableTasks.push_back( e_Tutorial_Hint_Rock );
s_completableTasks.push_back( e_Tutorial_Hint_Stone );
s_completableTasks.push_back( e_Tutorial_Hint_Planks );
s_completableTasks.push_back( e_Tutorial_Hint_Sapling );
s_completableTasks.push_back( e_Tutorial_Hint_Unbreakable );
s_completableTasks.push_back( e_Tutorial_Hint_Water );
s_completableTasks.push_back( e_Tutorial_Hint_Lava );
s_completableTasks.push_back( e_Tutorial_Hint_Sand );
s_completableTasks.push_back( e_Tutorial_Hint_Gravel );
s_completableTasks.push_back( e_Tutorial_Hint_Gold_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Iron_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Coal_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Tree_Trunk );
s_completableTasks.push_back( e_Tutorial_Hint_Glass );
s_completableTasks.push_back( e_Tutorial_Hint_Leaves );
s_completableTasks.push_back( e_Tutorial_Hint_Lapis_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Lapis_Block );
s_completableTasks.push_back( e_Tutorial_Hint_Dispenser );
s_completableTasks.push_back( e_Tutorial_Hint_Sandstone );
s_completableTasks.push_back( e_Tutorial_Hint_Note_Block );
s_completableTasks.push_back( e_Tutorial_Hint_Powered_Rail );
s_completableTasks.push_back( e_Tutorial_Hint_Detector_Rail );
s_completableTasks.push_back( e_Tutorial_Hint_Tall_Grass );
s_completableTasks.push_back( e_Tutorial_Hint_Wool );
s_completableTasks.push_back( e_Tutorial_Hint_Flower );
s_completableTasks.push_back( e_Tutorial_Hint_Mushroom );
s_completableTasks.push_back( e_Tutorial_Hint_Gold_Block );
s_completableTasks.push_back( e_Tutorial_Hint_Iron_Block );
s_completableTasks.push_back( e_Tutorial_Hint_Stone_Slab );
s_completableTasks.push_back( e_Tutorial_Hint_Red_Brick );
s_completableTasks.push_back( e_Tutorial_Hint_Tnt );
s_completableTasks.push_back( e_Tutorial_Hint_Bookshelf );
s_completableTasks.push_back( e_Tutorial_Hint_Moss_Stone );
s_completableTasks.push_back( e_Tutorial_Hint_Obsidian );
s_completableTasks.push_back( e_Tutorial_Hint_Torch );
s_completableTasks.push_back( e_Tutorial_Hint_MobSpawner );
s_completableTasks.push_back( e_Tutorial_Hint_Chest );
s_completableTasks.push_back( e_Tutorial_Hint_Redstone );
s_completableTasks.push_back( e_Tutorial_Hint_Diamond_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Diamond_Block );
s_completableTasks.push_back( e_Tutorial_Hint_Crafting_Table );
s_completableTasks.push_back( e_Tutorial_Hint_Crops );
s_completableTasks.push_back( e_Tutorial_Hint_Farmland );
s_completableTasks.push_back( e_Tutorial_Hint_Furnace );
s_completableTasks.push_back( e_Tutorial_Hint_Sign );
s_completableTasks.push_back( e_Tutorial_Hint_Door_Wood );
s_completableTasks.push_back( e_Tutorial_Hint_Ladder );
s_completableTasks.push_back( e_Tutorial_Hint_Rail );
s_completableTasks.push_back( e_Tutorial_Hint_Stairs_Stone );
s_completableTasks.push_back( e_Tutorial_Hint_Lever );
s_completableTasks.push_back( e_Tutorial_Hint_PressurePlate );
s_completableTasks.push_back( e_Tutorial_Hint_Door_Iron );
s_completableTasks.push_back( e_Tutorial_Hint_Redstone_Ore );
s_completableTasks.push_back( e_Tutorial_Hint_Redstone_Torch );
s_completableTasks.push_back( e_Tutorial_Hint_Button );
s_completableTasks.push_back( e_Tutorial_Hint_Snow );
s_completableTasks.push_back( e_Tutorial_Hint_Ice );
s_completableTasks.push_back( e_Tutorial_Hint_Cactus );
s_completableTasks.push_back( e_Tutorial_Hint_Clay );
s_completableTasks.push_back( e_Tutorial_Hint_Sugarcane );
s_completableTasks.push_back( e_Tutorial_Hint_Record_Player );
s_completableTasks.push_back( e_Tutorial_Hint_Pumpkin );
s_completableTasks.push_back( e_Tutorial_Hint_Hell_Rock );
s_completableTasks.push_back( e_Tutorial_Hint_Hell_Sand );
s_completableTasks.push_back( e_Tutorial_Hint_Glowstone );
s_completableTasks.push_back( e_Tutorial_Hint_Portal );
s_completableTasks.push_back( e_Tutorial_Hint_Pumpkin_Lit );
s_completableTasks.push_back( e_Tutorial_Hint_Cake );
s_completableTasks.push_back( e_Tutorial_Hint_Redstone_Repeater );
s_completableTasks.push_back( e_Tutorial_Hint_Trapdoor );
s_completableTasks.push_back( e_Tutorial_Hint_Piston );
s_completableTasks.push_back( e_Tutorial_Hint_Sticky_Piston );
s_completableTasks.push_back( e_Tutorial_Hint_Monster_Stone_Egg );
s_completableTasks.push_back( e_Tutorial_Hint_Stone_Brick_Smooth );
s_completableTasks.push_back( e_Tutorial_Hint_Huge_Mushroom );
s_completableTasks.push_back( e_Tutorial_Hint_Iron_Fence );
s_completableTasks.push_back( e_Tutorial_Hint_Thin_Glass );
s_completableTasks.push_back( e_Tutorial_Hint_Melon );
s_completableTasks.push_back( e_Tutorial_Hint_Vine );
s_completableTasks.push_back( e_Tutorial_Hint_Fence_Gate );
s_completableTasks.push_back( e_Tutorial_Hint_Mycel );
s_completableTasks.push_back( e_Tutorial_Hint_Water_Lily );
s_completableTasks.push_back( e_Tutorial_Hint_Nether_Brick );
s_completableTasks.push_back( e_Tutorial_Hint_Nether_Fence );
s_completableTasks.push_back( e_Tutorial_Hint_Nether_Stalk );
s_completableTasks.push_back( e_Tutorial_Hint_Enchant_Table );
s_completableTasks.push_back( e_Tutorial_Hint_Brewing_Stand );
s_completableTasks.push_back( e_Tutorial_Hint_Cauldron );
s_completableTasks.push_back( e_Tutorial_Hint_End_Portal );
s_completableTasks.push_back( e_Tutorial_Hint_End_Portal_Frame );
s_completableTasks.push_back( e_Tutorial_Hint_Squid );
s_completableTasks.push_back( e_Tutorial_Hint_Cow );
s_completableTasks.push_back( e_Tutorial_Hint_Sheep );
s_completableTasks.push_back( e_Tutorial_Hint_Chicken );
s_completableTasks.push_back( e_Tutorial_Hint_Pig );
s_completableTasks.push_back( e_Tutorial_Hint_Wolf );
s_completableTasks.push_back( e_Tutorial_Hint_Creeper );
s_completableTasks.push_back( e_Tutorial_Hint_Skeleton );
s_completableTasks.push_back( e_Tutorial_Hint_Spider );
s_completableTasks.push_back( e_Tutorial_Hint_Zombie );
s_completableTasks.push_back( e_Tutorial_Hint_Pig_Zombie );
s_completableTasks.push_back( e_Tutorial_Hint_Ghast );
s_completableTasks.push_back( e_Tutorial_Hint_Slime );
s_completableTasks.push_back( e_Tutorial_Hint_Enderman );
s_completableTasks.push_back( e_Tutorial_Hint_Silverfish );
s_completableTasks.push_back( e_Tutorial_Hint_Cave_Spider );
s_completableTasks.push_back( e_Tutorial_Hint_MushroomCow );
s_completableTasks.push_back( e_Tutorial_Hint_SnowMan );
s_completableTasks.push_back( e_Tutorial_Hint_IronGolem );
s_completableTasks.push_back( e_Tutorial_Hint_EnderDragon );
s_completableTasks.push_back( e_Tutorial_Hint_Blaze );
s_completableTasks.push_back( e_Tutorial_Hint_Lava_Slime );
s_completableTasks.push_back( e_Tutorial_Hint_Ozelot );
s_completableTasks.push_back( e_Tutorial_Hint_Villager );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Shovel );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Hatchet );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Pickaxe );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Flint_And_Steel );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Apple );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bow );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Arrow );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Coal );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Diamond );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Iron_Ingot );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Gold_Ingot );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Sword );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Stick );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bowl );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Mushroom_Stew );
s_completableTasks.push_back( e_Tutorial_Hint_Item_String );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Feather );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Sulphur );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Hoe );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Seeds );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Wheat );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bread );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Helmet );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Chestplate );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Leggings );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Boots );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Flint );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Porkchop_Raw );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Porkchop_Cooked );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Painting );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Apple_Gold );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Sign );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Door_Wood );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bucket_Empty );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bucket_Water );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bucket_Lava );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Minecart );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Saddle );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Door_Iron );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Redstone );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Snowball );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Boat );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Leather );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Milk );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Brick );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Clay );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Reeds );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Paper );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Book );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Slimeball );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Minecart_Chest );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Minecart_Furnace );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Egg );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Compass );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Clock );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Yellow_Dust );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Fish_Raw );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Fish_Cooked );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Dye_Powder );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Bone );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Sugar );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Cake );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Diode );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Cookie );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Map );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Record );
s_completableTasks.push_back( e_Tutorial_Hint_White_Stone );
s_completableTasks.push_back( e_Tutorial_Hint_Dragon_Egg );
s_completableTasks.push_back( e_Tutorial_Hint_RedstoneLamp );
s_completableTasks.push_back( e_Tutorial_Hint_Cocoa);
s_completableTasks.push_back( e_Tutorial_Hint_EmeraldOre );
s_completableTasks.push_back( e_Tutorial_Hint_EmeraldBlock );
s_completableTasks.push_back( e_Tutorial_Hint_EnderChest );
s_completableTasks.push_back( e_Tutorial_Hint_TripwireSource );
s_completableTasks.push_back( e_Tutorial_Hint_Tripwire );
s_completableTasks.push_back( e_Tutorial_Hint_CobblestoneWall );
s_completableTasks.push_back( e_Tutorial_Hint_Flowerpot );
s_completableTasks.push_back( e_Tutorial_Hint_Anvil );
s_completableTasks.push_back( e_Tutorial_Hint_QuartzOre );
s_completableTasks.push_back( e_Tutorial_Hint_QuartzBlock );
s_completableTasks.push_back( e_Tutorial_Hint_WoolCarpet );
s_completableTasks.push_back( e_Tutorial_Hint_Potato );
s_completableTasks.push_back( e_Tutorial_Hint_Carrot );
s_completableTasks.push_back( e_Tutorial_Hint_CommandBlock );
s_completableTasks.push_back( e_Tutorial_Hint_Beacon );
s_completableTasks.push_back( e_Tutorial_Hint_Activator_Rail );
s_completableTasks.push_back( eTutorial_Telemetry_TrialStart );
s_completableTasks.push_back( eTutorial_Telemetry_Halfway );
s_completableTasks.push_back( eTutorial_Telemetry_Complete );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_1 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_2 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_3 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_4 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_5 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_6 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_7 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_8 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_9 );
s_completableTasks.push_back( eTutorial_Telemetry_Unused_10 );
s_completableTasks.push_back( e_Tutorial_State_Enchanting_Menu );
s_completableTasks.push_back( e_Tutorial_State_Farming );
s_completableTasks.push_back( e_Tutorial_State_Breeding );
s_completableTasks.push_back( e_Tutorial_State_Golem );
s_completableTasks.push_back( e_Tutorial_State_Trading );
s_completableTasks.push_back( e_Tutorial_State_Trading_Menu );
s_completableTasks.push_back( e_Tutorial_State_Anvil );
s_completableTasks.push_back( e_Tutorial_State_Anvil_Menu );
s_completableTasks.push_back( e_Tutorial_State_Enderchests );
s_completableTasks.push_back( e_Tutorial_State_Horse_Menu );
s_completableTasks.push_back( e_Tutorial_State_Hopper_Menu );
s_completableTasks.push_back( e_Tutorial_Hint_Wither );
s_completableTasks.push_back( e_Tutorial_Hint_Witch );
s_completableTasks.push_back( e_Tutorial_Hint_Bat );
s_completableTasks.push_back( e_Tutorial_Hint_Horse );
s_completableTasks.push_back( e_Tutorial_Hint_RedstoneBlock );
s_completableTasks.push_back( e_Tutorial_Hint_DaylightDetector );
s_completableTasks.push_back( e_Tutorial_Hint_Dropper );
s_completableTasks.push_back( e_Tutorial_Hint_Hopper );
s_completableTasks.push_back( e_Tutorial_Hint_Comparator );
s_completableTasks.push_back( e_Tutorial_Hint_ChestTrap );
s_completableTasks.push_back( e_Tutorial_Hint_HayBlock );
s_completableTasks.push_back( e_Tutorial_Hint_ClayHardened );
s_completableTasks.push_back( e_Tutorial_Hint_ClayHardenedColored );
s_completableTasks.push_back( e_Tutorial_Hint_CoalBlock );
s_completableTasks.push_back( e_Tutorial_State_Beacon_Menu );
s_completableTasks.push_back( e_Tutorial_State_Fireworks_Menu );
s_completableTasks.push_back( e_Tutorial_State_Horse );
s_completableTasks.push_back( e_Tutorial_State_Hopper );
s_completableTasks.push_back( e_Tutorial_State_Beacon );
s_completableTasks.push_back( e_Tutorial_State_Fireworks );
if( s_completableTasks.size() > TUTORIAL_PROFILE_STORAGE_BITS )
{
app.DebugPrintf("Warning: Too many tutorial completable tasks added, not enough bits allocated to stored them in the profile data");
assert(false);
}
}
Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
{
m_isFullTutorial = isFullTutorial;
m_fullTutorialComplete = false;
m_allTutorialsComplete = false;
hasRequestedUI = false;
uiTempDisabled = false;
m_hintDisplayed = false;
m_freezeTime = false;
m_timeFrozen = false;
m_UIScene = NULL;
m_allowShow = true;
m_bHasTickedOnce = false;
m_firstTickTime = 0;
m_lastMessage = NULL;
lastMessageTime = 0;
m_iTaskReminders = 0;
m_lastMessageState = e_Tutorial_State_Gameplay;
m_CurrentState = e_Tutorial_State_Gameplay;
m_hasStateChanged = false;
#ifdef _XBOX
m_hTutorialScene=NULL;
#endif
for(unsigned int i = 0; i < e_Tutorial_State_Max; ++i)
{
currentTask[i] = NULL;
currentFailedConstraint[i] = NULL;
}
// DEFAULT TASKS THAT ALL TUTORIALS SHARE
/*
*
*
* GAMEPLAY
*
*/
if(!isHintCompleted(e_Tutorial_Hint_Hold_To_Mine)) addHint(e_Tutorial_State_Gameplay, new TutorialHint(e_Tutorial_Hint_Hold_To_Mine, this, IDS_TUTORIAL_HINT_HOLD_TO_MINE, TutorialHint::e_Hint_HoldToMine) );
if(!isHintCompleted(e_Tutorial_Hint_Tool_Damaged)) addHint(e_Tutorial_State_Gameplay, new TutorialHint(e_Tutorial_Hint_Tool_Damaged, this, IDS_TUTORIAL_HINT_TOOL_DAMAGED, TutorialHint::e_Hint_ToolDamaged) );
if(!isHintCompleted(e_Tutorial_Hint_Swim_Up)) addHint(e_Tutorial_State_Gameplay, new TutorialHint(e_Tutorial_Hint_Swim_Up, this, IDS_TUTORIAL_HINT_SWIM_UP, TutorialHint::e_Hint_SwimUp) );
/*
* TILE HINTS
*/
int rockItems[] = {Tile::stone_Id};
if(!isHintCompleted(e_Tutorial_Hint_Rock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Rock, this, rockItems, 1 ) );
int stoneItems[] = {Tile::cobblestone_Id};
if(!isHintCompleted(e_Tutorial_Hint_Stone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone, this, stoneItems, 1 ) );
int plankItems[] = {Tile::wood_Id};
if(!isHintCompleted(e_Tutorial_Hint_Planks)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Planks, this, plankItems, 1 ) );
int saplingItems[] = {Tile::sapling_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sapling)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sapling, this, saplingItems, 1 ) );
int unbreakableItems[] = {Tile::unbreakable_Id};
if(!isHintCompleted(e_Tutorial_Hint_Unbreakable)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Unbreakable, this, unbreakableItems, 1 ) );
int waterItems[] = {Tile::water_Id, Tile::calmWater_Id};
if(!isHintCompleted(e_Tutorial_Hint_Water)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Water, this, waterItems, 2 ) );
int lavaItems[] = {Tile::lava_Id, Tile::calmLava_Id};
if(!isHintCompleted(e_Tutorial_Hint_Lava)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Lava, this, lavaItems, 2 ) );
int sandItems[] = {Tile::sand_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sand)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sand, this, sandItems, 1 ) );
int gravelItems[] = {Tile::gravel_Id};
if(!isHintCompleted(e_Tutorial_Hint_Gravel)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Gravel, this, gravelItems, 1 ) );
int goldOreItems[] = {Tile::goldOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_Gold_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Gold_Ore, this, goldOreItems, 1 ) );
int ironOreItems[] = {Tile::ironOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_Iron_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Iron_Ore, this, ironOreItems, 1 ) );
int coalOreItems[] = {Tile::coalOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_Coal_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Coal_Ore, this, coalOreItems, 1 ) );
int treeTrunkItems[] = {Tile::treeTrunk_Id};
if(!isHintCompleted(e_Tutorial_Hint_Tree_Trunk)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tree_Trunk, this, treeTrunkItems, 1 ) );
int leavesItems[] = {Tile::leaves_Id};
if(!isHintCompleted(e_Tutorial_Hint_Leaves)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Leaves, this, leavesItems, 1 ) );
int glassItems[] = {Tile::glass_Id};
if(!isHintCompleted(e_Tutorial_Hint_Glass)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Glass, this, glassItems, 1 ) );
int lapisOreItems[] = {Tile::lapisOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_Lapis_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Lapis_Ore, this, lapisOreItems, 1 ) );
int lapisBlockItems[] = {Tile::lapisBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_Lapis_Block)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Lapis_Block, this, lapisBlockItems, 1 ) );
int dispenserItems[] = {Tile::dispenser_Id};
if(!isHintCompleted(e_Tutorial_Hint_Dispenser)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Dispenser, this, dispenserItems, 1 ) );
int sandstoneItems[] = {Tile::sandStone_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sandstone))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sandstone, this, sandstoneItems, 1, -1, SandStoneTile::TYPE_DEFAULT ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sandstone, this, sandstoneItems, 1, -1, SandStoneTile::TYPE_HEIROGLYPHS ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sandstone, this, sandstoneItems, 1, -1, SandStoneTile::TYPE_SMOOTHSIDE ) );
}
int noteBlockItems[] = {Tile::noteblock_Id};
if(!isHintCompleted(e_Tutorial_Hint_Note_Block)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Note_Block, this, noteBlockItems, 1 ) );
int poweredRailItems[] = {Tile::goldenRail_Id};
if(!isHintCompleted(e_Tutorial_Hint_Powered_Rail)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Powered_Rail, this, poweredRailItems, 1 ) );
int detectorRailItems[] = {Tile::detectorRail_Id};
if(!isHintCompleted(e_Tutorial_Hint_Detector_Rail)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Detector_Rail, this, detectorRailItems, 1 ) );
int tallGrassItems[] = {Tile::tallgrass_Id};
if(!isHintCompleted(e_Tutorial_Hint_Tall_Grass))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tall_Grass, this, tallGrassItems, 1, -1, TallGrass::DEAD_SHRUB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tall_Grass, this, tallGrassItems, 1, -1, TallGrass::TALL_GRASS ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tall_Grass, this, tallGrassItems, 1, -1, TallGrass::FERN ) );
}
int woolItems[] = {Tile::wool_Id};
if(!isHintCompleted(e_Tutorial_Hint_Wool)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Wool, this, woolItems, 1 ) );
int flowerItems[] = {Tile::flower_Id, Tile::rose_Id};
if(!isHintCompleted(e_Tutorial_Hint_Flower)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Flower, this, flowerItems, 2 ) );
int mushroomItems[] = {Tile::mushroom_brown_Id, Tile::mushroom_red_Id};
if(!isHintCompleted(e_Tutorial_Hint_Mushroom)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Mushroom, this, mushroomItems, 2 ) );
int goldBlockItems[] = {Tile::goldBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_Gold_Block)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Gold_Block, this, goldBlockItems, 1 ) );
int ironBlockItems[] = {Tile::ironBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_Iron_Block)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Iron_Block, this, ironBlockItems, 1 ) );
int stoneSlabItems[] = {Tile::stoneSlabHalf_Id, Tile::stoneSlab_Id};
if(!isHintCompleted(e_Tutorial_Hint_Stone_Slab))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::STONE_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::SAND_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::WOOD_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::COBBLESTONE_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::BRICK_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::SMOOTHBRICK_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::NETHERBRICK_SLAB ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, stoneSlabItems, 2, -1, StoneSlabTile::QUARTZ_SLAB ) );
}
int woodSlabItems[] = {Tile::woodSlabHalf_Id, Tile::woodSlab_Id};
if(!isHintCompleted(e_Tutorial_Hint_Stone_Slab))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, woodSlabItems, 2, -1, TreeTile::BIRCH_TRUNK ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Slab, this, woodSlabItems, 2, -1, TreeTile::DARK_TRUNK ) );
}
int redBrickItems[] = {Tile::redBrick_Id};
if(!isHintCompleted(e_Tutorial_Hint_Red_Brick)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Red_Brick, this, redBrickItems, 1 ) );
int tntItems[] = {Tile::tnt_Id};
if(!isHintCompleted(e_Tutorial_Hint_Tnt)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tnt, this, tntItems, 1 ) );
int bookshelfItems[] = {Tile::bookshelf_Id};
if(!isHintCompleted(e_Tutorial_Hint_Bookshelf)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Bookshelf, this, bookshelfItems, 1 ) );
int mossStoneItems[] = {Tile::mossyCobblestone_Id};
if(!isHintCompleted(e_Tutorial_Hint_Moss_Stone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Moss_Stone, this, mossStoneItems, 1 ) );
int obsidianItems[] = {Tile::obsidian_Id};
if(!isHintCompleted(e_Tutorial_Hint_Obsidian)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Obsidian, this, obsidianItems, 1 ) );
int torchItems[] = {Tile::torch_Id};
if(!isHintCompleted(e_Tutorial_Hint_Torch)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Torch, this, torchItems, 1 ) );
int mobSpawnerItems[] = {Tile::mobSpawner_Id};
if(!isHintCompleted(e_Tutorial_Hint_MobSpawner)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_MobSpawner, this, mobSpawnerItems, 1 ) );
int chestItems[] = {Tile::chest_Id};
if(!isHintCompleted(e_Tutorial_Hint_Chest)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Chest, this, chestItems, 1 ) );
int redstoneItems[] = {Tile::redStoneDust_Id};
if(!isHintCompleted(e_Tutorial_Hint_Redstone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Redstone, this, redstoneItems, 1, Item::redStone_Id ) );
int diamondOreItems[] = {Tile::diamondOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_Diamond_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Diamond_Ore, this, diamondOreItems, 1 ) );
int diamondBlockItems[] = {Tile::diamondBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_Diamond_Block)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Diamond_Block, this, diamondBlockItems, 1 ) );
int craftingTableItems[] = {Tile::workBench_Id};
if(!isHintCompleted(e_Tutorial_Hint_Crafting_Table)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Crafting_Table, this, craftingTableItems, 1 ) );
int cropsItems[] = {Tile::wheat_Id};
if(!isHintCompleted(e_Tutorial_Hint_Crops)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Crops, this, cropsItems, 1, -1, -1, 7 ) );
int farmlandItems[] = {Tile::farmland_Id};
if(!isHintCompleted(e_Tutorial_Hint_Farmland)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Farmland, this, farmlandItems, 1 ) );
int furnaceItems[] = {Tile::furnace_Id, Tile::furnace_lit_Id};
if(!isHintCompleted(e_Tutorial_Hint_Furnace)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Furnace, this, furnaceItems, 2 ) );
int signItems[] = {Tile::sign_Id, Tile::wallSign_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sign)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sign, this, signItems, 2, Item::sign_Id ) );
int doorWoodItems[] = {Tile::door_wood_Id};
if(!isHintCompleted(e_Tutorial_Hint_Door_Wood)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Door_Wood, this, doorWoodItems, 1, Item::door_wood->id ) );
int ladderItems[] = {Tile::ladder_Id};
if(!isHintCompleted(e_Tutorial_Hint_Ladder)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Ladder, this, ladderItems, 1 ) );
int stairsStoneItems[] = {Tile::stairs_stone_Id,Tile::stairs_bricks_Id,Tile::stairs_stoneBrick_Id,Tile::stairs_wood_Id,Tile::stairs_sprucewood_Id,Tile::stairs_birchwood_Id,Tile::stairs_netherBricks_Id,Tile::stairs_sandstone_Id,Tile::stairs_quartz_Id};
if(!isHintCompleted(e_Tutorial_Hint_Stairs_Stone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stairs_Stone, this, stairsStoneItems, 9 ) );
int railItems[] = {Tile::rail_Id};
if(!isHintCompleted(e_Tutorial_Hint_Rail)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Rail, this, railItems, 1 ) );
int leverItems[] = {Tile::lever_Id};
if(!isHintCompleted(e_Tutorial_Hint_Lever)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Lever, this, leverItems, 1 ) );
int pressurePlateItems[] = {Tile::pressurePlate_stone_Id, Tile::pressurePlate_wood_Id};
if(!isHintCompleted(e_Tutorial_Hint_PressurePlate)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_PressurePlate, this, pressurePlateItems, 2 ) );
int doorIronItems[] = {Tile::door_iron_Id};
if(!isHintCompleted(e_Tutorial_Hint_Door_Iron)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Door_Iron, this, doorIronItems, 1, Item::door_iron->id ) );
int redstoneOreItems[] = {Tile::redStoneOre_Id, Tile::redStoneOre_lit_Id};
if(!isHintCompleted(e_Tutorial_Hint_Redstone_Ore)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Redstone_Ore, this, redstoneOreItems, 2 ) );
int redstoneTorchItems[] = {Tile::redstoneTorch_off_Id, Tile::redstoneTorch_on_Id};
if(!isHintCompleted(e_Tutorial_Hint_Redstone_Torch)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Redstone_Torch, this, redstoneTorchItems, 2 ) );
int buttonItems[] = {Tile::button_stone_Id, Tile::button_wood_Id};
if(!isHintCompleted(e_Tutorial_Hint_Button)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Button, this, buttonItems, 2 ) );
int snowItems[] = {Tile::snow_Id};
if(!isHintCompleted(e_Tutorial_Hint_Snow)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Snow, this, snowItems, 1 ) );
int iceItems[] = {Tile::ice_Id};
if(!isHintCompleted(e_Tutorial_Hint_Ice)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Ice, this, iceItems, 1 ) );
int cactusItems[] = {Tile::cactus_Id};
if(!isHintCompleted(e_Tutorial_Hint_Cactus)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Cactus, this, cactusItems, 1 ) );
int clayItems[] = {Tile::clay_Id};
if(!isHintCompleted(e_Tutorial_Hint_Clay)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Clay, this, clayItems, 1 ) );
int sugarCaneItems[] = {Tile::reeds_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sugarcane)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sugarcane, this, sugarCaneItems, 1 ) );
int recordPlayerItems[] = {Tile::jukebox_Id};
if(!isHintCompleted(e_Tutorial_Hint_Record_Player)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Record_Player, this, recordPlayerItems, 1 ) );
int pumpkinItems[] = {Tile::pumpkin_Id};
if(!isHintCompleted(e_Tutorial_Hint_Pumpkin)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Pumpkin, this, pumpkinItems, 1, -1, -1, 0 ) );
int hellRockItems[] = {Tile::netherRack_Id};
if(!isHintCompleted(e_Tutorial_Hint_Hell_Rock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Hell_Rock, this, hellRockItems, 1 ) );
int hellSandItems[] = {Tile::soulsand_Id};
if(!isHintCompleted(e_Tutorial_Hint_Hell_Sand)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Hell_Sand, this, hellSandItems, 1 ) );
int glowstoneItems[] = {Tile::glowstone_Id};
if(!isHintCompleted(e_Tutorial_Hint_Glowstone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Glowstone, this, glowstoneItems, 1 ) );
int portalItems[] = {Tile::portalTile_Id};
if(!isHintCompleted(e_Tutorial_Hint_Portal)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Portal, this, portalItems, 1 ) );
int pumpkinLitItems[] = {Tile::litPumpkin_Id};
if(!isHintCompleted(e_Tutorial_Hint_Pumpkin_Lit)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Pumpkin_Lit, this, pumpkinLitItems, 1, -1, -1, 0 ) );
int cakeItems[] = {Tile::cake_Id};
if(!isHintCompleted(e_Tutorial_Hint_Cake)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Cake, this, cakeItems, 1 ) );
int redstoneRepeaterItems[] = {Tile::diode_on_Id, Tile::diode_off_Id};
if(!isHintCompleted(e_Tutorial_Hint_Redstone_Repeater)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Redstone_Repeater, this, redstoneRepeaterItems, 2, Item::repeater_Id ) );
int trapdoorItems[] = {Tile::trapdoor_Id};
if(!isHintCompleted(e_Tutorial_Hint_Trapdoor)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Trapdoor, this, trapdoorItems, 1 ) );
int pistonItems[] = {Tile::pistonBase_Id};
if(!isHintCompleted(e_Tutorial_Hint_Piston)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Piston, this, pistonItems, 1 ) );
int stickyPistonItems[] = {Tile::pistonStickyBase_Id};
if(!isHintCompleted(e_Tutorial_Hint_Sticky_Piston)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sticky_Piston, this, stickyPistonItems, 1 ) );
int monsterStoneEggItems[] = {Tile::monsterStoneEgg_Id};
if(!isHintCompleted(e_Tutorial_Hint_Monster_Stone_Egg)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Monster_Stone_Egg, this, monsterStoneEggItems, 1 ) );
int stoneBrickSmoothItems[] = {Tile::stoneBrick_Id};
if(!isHintCompleted(e_Tutorial_Hint_Stone_Brick_Smooth)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Stone_Brick_Smooth, this, stoneBrickSmoothItems, 1 ) );
int hugeMushroomItems[] = {Tile::hugeMushroom_brown_Id,Tile::hugeMushroom_red_Id};
if(!isHintCompleted(e_Tutorial_Hint_Huge_Mushroom)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Huge_Mushroom, this, hugeMushroomItems, 2 ) );
int ironFenceItems[] = {Tile::ironFence_Id};
if(!isHintCompleted(e_Tutorial_Hint_Iron_Fence)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Iron_Fence, this, ironFenceItems, 1 ) );
int thisGlassItems[] = {Tile::thinGlass_Id};
if(!isHintCompleted(e_Tutorial_Hint_Thin_Glass)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Thin_Glass, this, thisGlassItems, 1 ) );
int melonItems[] = {Tile::melon_Id};
if(!isHintCompleted(e_Tutorial_Hint_Melon)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Melon, this, melonItems, 1 ) );
int vineItems[] = {Tile::vine_Id};
if(!isHintCompleted(e_Tutorial_Hint_Vine)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Vine, this, vineItems, 1 ) );
int fenceGateItems[] = {Tile::fenceGate_Id};
if(!isHintCompleted(e_Tutorial_Hint_Fence_Gate)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Fence_Gate, this, fenceGateItems, 1 ) );
int mycelItems[] = {Tile::mycel_Id};
if(!isHintCompleted(e_Tutorial_Hint_Mycel)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Mycel, this, mycelItems, 1 ) );
int waterLilyItems[] = {Tile::waterLily_Id};
if(!isHintCompleted(e_Tutorial_Hint_Water_Lily)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Water_Lily, this, waterLilyItems, 1 ) );
int netherBrickItems[] = {Tile::netherBrick_Id};
if(!isHintCompleted(e_Tutorial_Hint_Nether_Brick)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Nether_Brick, this, netherBrickItems, 1 ) );
int netherFenceItems[] = {Tile::netherFence_Id};
if(!isHintCompleted(e_Tutorial_Hint_Nether_Fence)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Nether_Fence, this, netherFenceItems, 1 ) );
int netherStalkItems[] = {Tile::netherStalk_Id};
if(!isHintCompleted(e_Tutorial_Hint_Nether_Stalk)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Nether_Stalk, this, netherStalkItems, 1 ) );
int enchantTableItems[] = {Tile::enchantTable_Id};
if(!isHintCompleted(e_Tutorial_Hint_Enchant_Table)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Enchant_Table, this, enchantTableItems, 1 ) );
int brewingStandItems[] = {Tile::brewingStand_Id};
if(!isHintCompleted(e_Tutorial_Hint_Brewing_Stand)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Brewing_Stand, this, brewingStandItems, 1, Item::brewingStand_Id ) );
int cauldronItems[] = {Tile::cauldron_Id};
if(!isHintCompleted(e_Tutorial_Hint_Cauldron)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Cauldron, this, cauldronItems, 1, Item::cauldron_Id ) );
int endPortalItems[] = {Tile::endPortalTile_Id};
if(!isHintCompleted(e_Tutorial_Hint_End_Portal)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_End_Portal, this, endPortalItems, 1, -2 ) );
int endPortalFrameItems[] = {Tile::endPortalFrameTile_Id};
if(!isHintCompleted(e_Tutorial_Hint_End_Portal_Frame)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_End_Portal_Frame, this, endPortalFrameItems, 1 ) );
int whiteStoneItems[] = {Tile::endStone_Id};
if(!isHintCompleted(e_Tutorial_Hint_White_Stone)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_White_Stone, this, whiteStoneItems, 1 ) );
int dragonEggItems[] = {Tile::dragonEgg_Id};
if(!isHintCompleted(e_Tutorial_Hint_Dragon_Egg)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Dragon_Egg, this, dragonEggItems, 1 ) );
int redstoneLampItems[] = {Tile::redstoneLight_Id, Tile::redstoneLight_lit_Id};
if(!isHintCompleted(e_Tutorial_Hint_RedstoneLamp)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_RedstoneLamp, this, redstoneLampItems, 2 ) );
int cocoaItems[] = {Tile::cocoa_Id};
if(!isHintCompleted(e_Tutorial_Hint_Cocoa)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Cocoa, this, cocoaItems, 1, Item::dye_powder_Id, -1, DyePowderItem::BROWN) );
int emeraldOreItems[] = {Tile::emeraldOre_Id};
if(!isHintCompleted(e_Tutorial_Hint_EmeraldOre)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_EmeraldOre, this, emeraldOreItems, 1 ) );
int emeraldBlockItems[] = {Tile::emeraldBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_EmeraldBlock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_EmeraldBlock, this, emeraldBlockItems, 1 ) );
int enderChestItems[] = {Tile::enderChest_Id};
if(!isHintCompleted(e_Tutorial_Hint_EnderChest)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_EnderChest, this, enderChestItems, 1 ) );
int tripwireSourceItems[] = {Tile::tripWireSource_Id};
if(!isHintCompleted(e_Tutorial_Hint_TripwireSource)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_TripwireSource, this, tripwireSourceItems, 1 ) );
int tripwireItems[] = {Tile::tripWire_Id};
if(!isHintCompleted(e_Tutorial_Hint_Tripwire)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tripwire, this, tripwireItems, 1, Item::string_Id ) );
int cobblestoneWallItems[] = {Tile::cobbleWall_Id};
if(!isHintCompleted(e_Tutorial_Hint_CobblestoneWall))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_CobblestoneWall, this, cobblestoneWallItems, 1, -1, WallTile::TYPE_NORMAL ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_CobblestoneWall, this, cobblestoneWallItems, 1, -1, WallTile::TYPE_MOSSY ) );
}
int flowerpotItems[] = {Tile::flowerPot_Id};
if(!isHintCompleted(e_Tutorial_Hint_Flowerpot)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Flowerpot, this, flowerpotItems, 1, Item::flowerPot_Id ) );
int anvilItems[] = {Tile::anvil_Id};
if(!isHintCompleted(e_Tutorial_Hint_Anvil)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Anvil, this, anvilItems, 1 ) );
int quartzOreItems[] = {Tile::netherQuartz_Id};
if(!isHintCompleted(e_Tutorial_Hint_QuartzOre)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzOre, this, quartzOreItems, 1 ) );
int quartzBlockItems[] = {Tile::quartzBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_QuartzBlock))
{
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzBlock, this, quartzBlockItems, 1, -1, QuartzBlockTile::TYPE_DEFAULT ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzBlock, this, quartzBlockItems, 1, -1, QuartzBlockTile::TYPE_CHISELED ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzBlock, this, quartzBlockItems, 1, -1, QuartzBlockTile::TYPE_LINES_Y ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzBlock, this, quartzBlockItems, 1, -1, QuartzBlockTile::TYPE_LINES_X ) );
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_QuartzBlock, this, quartzBlockItems, 1, -1, QuartzBlockTile::TYPE_LINES_Z ) );
}
int carpetItems[] = {Tile::woolCarpet_Id};
if(!isHintCompleted(e_Tutorial_Hint_WoolCarpet)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_WoolCarpet, this, carpetItems, 1 ) );
int potatoItems[] = {Tile::potatoes_Id};
if(!isHintCompleted(e_Tutorial_Hint_Potato)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Potato, this, potatoItems, 1, -1, -1, 7 ) );
int carrotItems[] = {Tile::carrots_Id};
if(!isHintCompleted(e_Tutorial_Hint_Carrot)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Carrot, this, carrotItems, 1, -1, -1, 7 ) );
int commandBlockItems[] = {Tile::commandBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_CommandBlock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_CommandBlock, this, commandBlockItems, 1 ) );
int beaconItems[] = {Tile::beacon_Id};
if(!isHintCompleted(e_Tutorial_Hint_Beacon)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Beacon, this, beaconItems, 1 ) );
int activatorRailItems[] = {Tile::activatorRail_Id};
if(!isHintCompleted(e_Tutorial_Hint_Activator_Rail)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Activator_Rail, this, activatorRailItems, 1 ) );
int redstoneBlockItems[] = {Tile::redstoneBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_RedstoneBlock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_RedstoneBlock, this, redstoneBlockItems, 1 ) );
int daylightDetectorItems[] = {Tile::daylightDetector_Id};
if(!isHintCompleted(e_Tutorial_Hint_DaylightDetector)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_DaylightDetector, this, daylightDetectorItems, 1 ) );
int dropperItems[] = {Tile::dropper_Id};
if(!isHintCompleted(e_Tutorial_Hint_Dropper)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Dropper, this, dropperItems, 1 ) );
int hopperItems[] = {Tile::hopper_Id};
if(!isHintCompleted(e_Tutorial_Hint_Hopper)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Hopper, this, hopperItems, 1 ) );
int comparatorItems[] = {Tile::comparator_off_Id, Tile::comparator_on_Id};
if(!isHintCompleted(e_Tutorial_Hint_Comparator)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Comparator, this, comparatorItems, 2, Item::comparator_Id ) );
int trappedChestItems[] = {Tile::chest_trap_Id};
if(!isHintCompleted(e_Tutorial_Hint_ChestTrap)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_ChestTrap, this, trappedChestItems, 1 ) );
int hayBlockItems[] = {Tile::hayBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_HayBlock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_HayBlock, this, hayBlockItems, 1 ) );
int clayHardenedItems[] = {Tile::clayHardened_Id};
if(!isHintCompleted(e_Tutorial_Hint_ClayHardened)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_ClayHardened, this, clayHardenedItems, 1 ) );
int clayHardenedColoredItems[] = {Tile::clayHardened_colored_Id};
if(!isHintCompleted(e_Tutorial_Hint_ClayHardenedColored)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_ClayHardenedColored, this, clayHardenedColoredItems, 1 ) );
int coalBlockItems[] = {Tile::coalBlock_Id};
if(!isHintCompleted(e_Tutorial_Hint_CoalBlock)) addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_CoalBlock, this, coalBlockItems, 1 ) );
/*
* ENTITY HINTS
*/
if(!isHintCompleted(e_Tutorial_Hint_Squid)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Squid, this, IDS_DESC_SQUID, IDS_SQUID, eTYPE_SQUID ) );
if(!isHintCompleted(e_Tutorial_Hint_Cow)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Cow, this, IDS_DESC_COW, IDS_COW, eTYPE_COW ) );
if(!isHintCompleted(e_Tutorial_Hint_Sheep)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Sheep, this, IDS_DESC_SHEEP, IDS_SHEEP, eTYPE_SHEEP ) );
if(!isHintCompleted(e_Tutorial_Hint_Chicken)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Chicken, this, IDS_DESC_CHICKEN, IDS_CHICKEN, eTYPE_CHICKEN ) );
if(!isHintCompleted(e_Tutorial_Hint_Pig)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Pig, this, IDS_DESC_PIG, IDS_PIG, eTYPE_PIG ) );
if(!isHintCompleted(e_Tutorial_Hint_Wolf)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Wolf, this, IDS_DESC_WOLF, IDS_WOLF, eTYPE_WOLF ) );
if(!isHintCompleted(e_Tutorial_Hint_Creeper)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Creeper, this, IDS_DESC_CREEPER, IDS_CREEPER, eTYPE_CREEPER ) );
if(!isHintCompleted(e_Tutorial_Hint_Skeleton)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Skeleton, this, IDS_DESC_SKELETON, IDS_SKELETON, eTYPE_SKELETON ) );
if(!isHintCompleted(e_Tutorial_Hint_Spider)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Spider, this, IDS_DESC_SPIDER, IDS_SPIDER, eTYPE_SPIDER ) );
if(!isHintCompleted(e_Tutorial_Hint_Zombie)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Zombie, this, IDS_DESC_ZOMBIE, IDS_ZOMBIE, eTYPE_ZOMBIE ) );
if(!isHintCompleted(e_Tutorial_Hint_Pig_Zombie)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Pig_Zombie, this, IDS_DESC_PIGZOMBIE, IDS_PIGZOMBIE, eTYPE_PIGZOMBIE ) );
if(!isHintCompleted(e_Tutorial_Hint_Ghast)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Ghast, this, IDS_DESC_GHAST, IDS_GHAST, eTYPE_GHAST ) );
if(!isHintCompleted(e_Tutorial_Hint_Slime)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Slime, this, IDS_DESC_SLIME, IDS_SLIME, eTYPE_SLIME ) );
if(!isHintCompleted(e_Tutorial_Hint_Enderman)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Enderman, this, IDS_DESC_ENDERMAN, IDS_ENDERMAN, eTYPE_ENDERMAN ) );
if(!isHintCompleted(e_Tutorial_Hint_Silverfish)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Silverfish, this, IDS_DESC_SILVERFISH, IDS_SILVERFISH, eTYPE_SILVERFISH ) );
if(!isHintCompleted(e_Tutorial_Hint_Cave_Spider)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Cave_Spider, this, IDS_DESC_CAVE_SPIDER, IDS_CAVE_SPIDER, eTYPE_CAVESPIDER ) );
if(!isHintCompleted(e_Tutorial_Hint_MushroomCow)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_MushroomCow, this, IDS_DESC_MUSHROOM_COW, IDS_MUSHROOM_COW, eTYPE_MUSHROOMCOW) );
if(!isHintCompleted(e_Tutorial_Hint_SnowMan)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_SnowMan, this, IDS_DESC_SNOWMAN, IDS_SNOWMAN, eTYPE_SNOWMAN ) );
if(!isHintCompleted(e_Tutorial_Hint_IronGolem)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_IronGolem, this, IDS_DESC_IRONGOLEM, IDS_IRONGOLEM, eTYPE_VILLAGERGOLEM ) );
if(!isHintCompleted(e_Tutorial_Hint_EnderDragon)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_EnderDragon, this, IDS_DESC_ENDERDRAGON, IDS_ENDERDRAGON, eTYPE_ENDERDRAGON ) );
if(!isHintCompleted(e_Tutorial_Hint_Blaze)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Blaze, this, IDS_DESC_BLAZE, IDS_BLAZE, eTYPE_BLAZE ) );
if(!isHintCompleted(e_Tutorial_Hint_Lava_Slime)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Lava_Slime, this, IDS_DESC_LAVA_SLIME, IDS_LAVA_SLIME, eTYPE_LAVASLIME ) );
if(!isHintCompleted(e_Tutorial_Hint_Ozelot)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Ozelot, this, IDS_DESC_OZELOT, IDS_OZELOT, eTYPE_OCELOT ) );
if(!isHintCompleted(e_Tutorial_Hint_Villager)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Villager, this, IDS_DESC_VILLAGER, IDS_VILLAGER, eTYPE_VILLAGER) );
if(!isHintCompleted(e_Tutorial_Hint_Wither)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Wither, this, IDS_DESC_WITHER, IDS_WITHER, eTYPE_WITHERBOSS) );
if(!isHintCompleted(e_Tutorial_Hint_Witch)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Witch, this, IDS_DESC_WITCH, IDS_WITCH, eTYPE_WITCH) );
if(!isHintCompleted(e_Tutorial_Hint_Bat)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Bat, this, IDS_DESC_BAT, IDS_BAT, eTYPE_BAT) );
if(!isHintCompleted(e_Tutorial_Hint_Horse)) addHint(e_Tutorial_State_Gameplay, new LookAtEntityHint(e_Tutorial_Hint_Horse, this, IDS_DESC_HORSE, IDS_HORSE, eTYPE_HORSE) );
/*
* ITEM HINTS
*/
int shovelItems[] = {Item::shovel_wood->id, Item::shovel_stone->id, Item::shovel_iron->id, Item::shovel_gold->id, Item::shovel_diamond->id};
if(!isHintCompleted(e_Tutorial_Hint_Item_Shovel)) addHint(e_Tutorial_State_Gameplay, new DiggerItemHint(e_Tutorial_Hint_Item_Shovel, this, IDS_TUTORIAL_HINT_DIGGER_ITEM_SHOVEL, shovelItems, 5) );
int hatchetItems[] = {Item::hatchet_wood->id, Item::hatchet_stone->id, Item::hatchet_iron->id, Item::hatchet_gold->id, Item::hatchet_diamond->id};
if(!isHintCompleted(e_Tutorial_Hint_Item_Hatchet)) addHint(e_Tutorial_State_Gameplay, new DiggerItemHint(e_Tutorial_Hint_Item_Hatchet, this, IDS_TUTORIAL_HINT_DIGGER_ITEM_HATCHET, hatchetItems, 5 ) );
int pickaxeItems[] = {Item::pickAxe_wood->id, Item::pickAxe_stone->id, Item::pickAxe_iron->id, Item::pickAxe_gold->id, Item::pickAxe_diamond->id};
if(!isHintCompleted(e_Tutorial_Hint_Item_Pickaxe)) addHint(e_Tutorial_State_Gameplay, new DiggerItemHint(e_Tutorial_Hint_Item_Pickaxe, this, IDS_TUTORIAL_HINT_DIGGER_ITEM_PICKAXE, pickaxeItems, 5 ) );
/*
*
*
* INVENTORY
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Inventory_Menu) )
{
ProcedureCompoundTask *inventoryOverviewTask = new ProcedureCompoundTask( this );
inventoryOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_INV_OVERVIEW, IDS_TUTORIAL_PROMPT_INV_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_Inventory) );
inventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_INV_PICK_UP, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
inventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_INV_MOVE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
inventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_INV_DROP, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
inventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_INV_INFO, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Inventory_Menu, inventoryOverviewTask );
}
/*
*
*
* CREATIVE INVENTORY
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Creative_Inventory_Menu) )
{
ProcedureCompoundTask *creativeInventoryOverviewTask = new ProcedureCompoundTask( this );
creativeInventoryOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_OVERVIEW, IDS_TUTORIAL_PROMPT_CREATIVE_INV_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_CreativeInventory) );
creativeInventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_PICK_UP, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
creativeInventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_MOVE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
creativeInventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_DROP, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
creativeInventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_NAV, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
creativeInventoryOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CREATIVE_INV_INFO, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Creative_Inventory_Menu, creativeInventoryOverviewTask );
}
/*
*
*
* CRAFTING
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_2x2Crafting_Menu ) )
{
ProcedureCompoundTask *craftingOverviewTask = new ProcedureCompoundTask( this );
craftingOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_CRAFT_OVERVIEW, IDS_TUTORIAL_PROMPT_CRAFT_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_Crafting) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_NAV, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_CREATE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_CRAFT_TABLE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_INVENTORY, IDS_TUTORIAL_PROMPT_PRESS_X_TO_TOGGLE_DESCRIPTION, false, ACTION_MENU_X) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_DESCRIPTION, IDS_TUTORIAL_PROMPT_PRESS_X_TO_TOGGLE_INGREDIENTS, false, ACTION_MENU_X) );
craftingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_CRAFT_INGREDIENTS, IDS_TUTORIAL_PROMPT_PRESS_X_TO_TOGGLE_INVENTORY, false, ACTION_MENU_X) );
addTask(e_Tutorial_State_2x2Crafting_Menu, craftingOverviewTask );
}
// Other tasks can be added in the derived classes
addHint(e_Tutorial_State_2x2Crafting_Menu, new TutorialHint(e_Tutorial_Hint_Always_On, this, IDS_TUTORIAL_HINT_CRAFT_NO_INGREDIENTS, TutorialHint::e_Hint_NoIngredients) );
addHint(e_Tutorial_State_3x3Crafting_Menu, new TutorialHint(e_Tutorial_Hint_Always_On, this, IDS_TUTORIAL_HINT_CRAFT_NO_INGREDIENTS, TutorialHint::e_Hint_NoIngredients) );
/*
*
*
* FURNACE
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Furnace_Menu ) )
{
ProcedureCompoundTask *furnaceOverviewTask = new ProcedureCompoundTask( this );
furnaceOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_FURNACE_OVERVIEW, IDS_TUTORIAL_PROMPT_FURNACE_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_Furnace) );
furnaceOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FURNACE_METHOD, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
furnaceOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FURNACE_FUELS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
furnaceOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FURNACE_INGREDIENTS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Furnace_Menu, furnaceOverviewTask );
}
// Other tasks can be added in the derived classes
/*
*
*
* BREWING MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Brewing_Menu ) )
{
ProcedureCompoundTask *brewingOverviewTask = new ProcedureCompoundTask( this );
brewingOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_BREWING_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_BREWING_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_BrewingMenu) );
brewingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BREWING_MENU_METHOD, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
brewingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BREWING_MENU_BASIC_INGREDIENTS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
brewingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BREWING_MENU_EXTENDED_INGREDIENTS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
brewingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BREWING_MENU_EXTENDED_INGREDIENTS_2, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Brewing_Menu, brewingOverviewTask );
}
// Other tasks can be added in the derived classes
/*
*
*
* ENCHANTING MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Enchanting_Menu ) )
{
ProcedureCompoundTask *enchantingOverviewTask = new ProcedureCompoundTask( this );
enchantingOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_ENCHANTING_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_EnchantingMenu) );
enchantingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_START, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
enchantingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_ENCHANTMENTS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
enchantingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_COST, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
enchantingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_ENCHANT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
enchantingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ENCHANTING_MENU_BETTER_ENCHANTMENTS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Enchanting_Menu, enchantingOverviewTask );
}
// Other tasks can be added in the derived classes
/*
*
*
* ANVIL MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Anvil_Menu ) )
{
ProcedureCompoundTask *anvilOverviewTask = new ProcedureCompoundTask( this );
anvilOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_ANVIL_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_AnvilMenu) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_START, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_REPAIR, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_SACRIFICE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_ENCHANT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_COST, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_RENAMING, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
anvilOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_ANVIL_MENU_SMITH, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Anvil_Menu, anvilOverviewTask );
}
// Other tasks can be added in the derived classes
/*
*
*
* TRADING MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Trading_Menu ) )
{
ProcedureCompoundTask *tradingOverviewTask = new ProcedureCompoundTask( this );
tradingOverviewTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_TRADING_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_TradingMenu) );
tradingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_START, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
tradingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_UNAVAILABLE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
tradingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_DETAILS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
tradingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_INVENTORY, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
tradingOverviewTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_TRADING_MENU_TRADE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Trading_Menu, tradingOverviewTask );
}
// Other tasks can be added in the derived classes
/*
*
*
* HORSE ENCOUNTER
*
*/
if(isFullTutorial || !isStateCompleted(e_Tutorial_State_Horse) )
{
addTask(e_Tutorial_State_Horse,
new HorseChoiceTask(this, IDS_TUTORIAL_TASK_HORSE_OVERVIEW, IDS_TUTORIAL_TASK_DONKEY_OVERVIEW, IDS_TUTORIAL_TASK_MULE_OVERVIEW, IDS_TUTORIAL_PROMPT_HORSE_OVERVIEW,
true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Horse) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_INTRO, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_PURPOSE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_TAMING, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_TAMING2, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
// 4J-JEV: Only force the RideEntityTask if we're on the full-tutorial.
if (isFullTutorial) addTask(e_Tutorial_State_Horse, new RideEntityTask(eTYPE_HORSE, this, IDS_TUTORIAL_TASK_HORSE_RIDE, true, NULL, false, false, false) );
else addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_RIDE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_SADDLES, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_SADDLEBAGS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse, new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_BREEDING, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
/*
*
*
* HORSE MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Horse_Menu ) )
{
ProcedureCompoundTask *horseMenuTask = new ProcedureCompoundTask( this );
horseMenuTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_HORSE_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_HORSE_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_HorseMenu) );
horseMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_MENU_LAYOUT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
horseMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_MENU_EQUIPMENT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
horseMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_HORSE_MENU_SADDLEBAGS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Horse_Menu, horseMenuTask );
}
/*
*
*
* FIREWORKS MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Fireworks_Menu ) )
{
ProcedureCompoundTask *fireworksMenuTask = new ProcedureCompoundTask( this );
fireworksMenuTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_FIREWORK_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_FireworksMenu) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_BASIC_START, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_BASIC_STARS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_BASIC_HEIGHT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_BASIC_CRAFT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_ADV_START, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_ADV_COLOUR, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_ADV_SHAPE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_ADV_EFFECT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
fireworksMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_MENU_ADV_FADE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Fireworks_Menu, fireworksMenuTask );
}
/*
*
*
* BEACON MENU
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Beacon_Menu ) )
{
ProcedureCompoundTask *beaconMenuTask = new ProcedureCompoundTask( this );
beaconMenuTask->AddTask( new ChoiceTask(this, IDS_TUTORIAL_TASK_BEACON_MENU_OVERVIEW, IDS_TUTORIAL_PROMPT_BEACON_MENU_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State, eTelemetryTutorial_BeaconMenu) );
beaconMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_MENU_PRIMARY_POWERS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
beaconMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_MENU_SECONDARY_POWER, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
beaconMenuTask->AddTask( new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_MENU_ACTIVATION, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Beacon_Menu, beaconMenuTask );
}
/*
*
*
* MINECART
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Riding_Minecart ) )
{
addTask(e_Tutorial_State_Riding_Minecart, new ChoiceTask(this, IDS_TUTORIAL_TASK_MINECART_OVERVIEW, IDS_TUTORIAL_PROMPT_MINECART_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Minecart) );
addTask(e_Tutorial_State_Riding_Minecart, new InfoTask(this, IDS_TUTORIAL_TASK_MINECART_RAILS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Riding_Minecart, new InfoTask(this, IDS_TUTORIAL_TASK_MINECART_POWERED_RAILS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Riding_Minecart, new InfoTask(this, IDS_TUTORIAL_TASK_MINECART_PUSHING, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
/*
*
*
* BOAT
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Riding_Boat ) )
{
addTask(e_Tutorial_State_Riding_Boat, new ChoiceTask(this, IDS_TUTORIAL_TASK_BOAT_OVERVIEW, IDS_TUTORIAL_PROMPT_BOAT_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Boat) );
addTask(e_Tutorial_State_Riding_Boat, new InfoTask(this, IDS_TUTORIAL_TASK_BOAT_STEER, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
/*
*
*
* FISHING
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Fishing ) )
{
addTask(e_Tutorial_State_Fishing, new ChoiceTask(this, IDS_TUTORIAL_TASK_FISHING_OVERVIEW, IDS_TUTORIAL_PROMPT_FISHING_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Fishing) );
addTask(e_Tutorial_State_Fishing, new InfoTask(this, IDS_TUTORIAL_TASK_FISHING_CAST, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Fishing, new InfoTask(this, IDS_TUTORIAL_TASK_FISHING_FISH, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Fishing, new InfoTask(this, IDS_TUTORIAL_TASK_FISHING_USES, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
/*
*
*
* BED
*
*/
if(isFullTutorial || !isStateCompleted( e_Tutorial_State_Bed ) )
{
addTask(e_Tutorial_State_Bed, new ChoiceTask(this, IDS_TUTORIAL_TASK_BED_OVERVIEW, IDS_TUTORIAL_PROMPT_BED_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Bed) );
addTask(e_Tutorial_State_Bed, new InfoTask(this, IDS_TUTORIAL_TASK_BED_PLACEMENT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Bed, new InfoTask(this, IDS_TUTORIAL_TASK_BED_MULTIPLAYER, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
/*
*
*
* FOOD BAR
*
*/
if(!isFullTutorial && !isStateCompleted( e_Tutorial_State_Food_Bar ) )
{
addTask(e_Tutorial_State_Food_Bar, new ChoiceTask(this, IDS_TUTORIAL_TASK_FOOD_BAR_OVERVIEW, IDS_TUTORIAL_PROMPT_FOOD_BAR_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_FoodBar) );
addTask(e_Tutorial_State_Food_Bar, new InfoTask(this, IDS_TUTORIAL_TASK_FOOD_BAR_DEPLETE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Food_Bar, new InfoTask(this, IDS_TUTORIAL_TASK_FOOD_BAR_HEAL, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Food_Bar, new InfoTask(this, IDS_TUTORIAL_TASK_FOOD_BAR_FEED, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
}
Tutorial::~Tutorial()
{
for(AUTO_VAR(it, m_globalConstraints.begin()); it != m_globalConstraints.end(); ++it)
{
delete (*it);
}
for(unordered_map<int, TutorialMessage *>::iterator it = messages.begin(); it != messages.end(); ++it)
{
delete (*it).second;
}
for(unsigned int i = 0; i < e_Tutorial_State_Max; ++i)
{
for(AUTO_VAR(it, activeTasks[i].begin()); it < activeTasks[i].end(); ++it)
{
delete (*it);
}
for(AUTO_VAR(it, hints[i].begin()); it < hints[i].end(); ++it)
{
delete (*it);
}
currentTask[i] = NULL;
currentFailedConstraint[i] = NULL;
}
}
void Tutorial::debugResetPlayerSavedProgress(int iPad)
{
#if ( defined __PS3__ || defined __ORBIS__ || defined _DURANGO || defined __PSVITA__)
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)StorageManager.GetGameDefinedProfileData(iPad);
#else
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)ProfileManager.GetGameDefinedProfileData(iPad);
#endif
ZeroMemory( pGameSettings->ucTutorialCompletion, TUTORIAL_PROFILE_STORAGE_BYTES );
pGameSettings->uiSpecialTutorialBitmask = 0;
}
void Tutorial::setCompleted( int completableId )
{
//if(app.GetGameSettingsDebugMask(m_iPad) && app.GetGameSettingsDebugMask()&(1L<<eDebugSetting_TipsAlwaysOn))
//{
// return;
//}
int completableIndex = -1;
for( AUTO_VAR(it, s_completableTasks.begin()); it < s_completableTasks.end(); ++it)
{
++completableIndex;
if( *it == completableId )
{
break;
}
}
if( completableIndex >= 0 && completableIndex < TUTORIAL_PROFILE_STORAGE_BITS )
{
// Set the bit for this position
#if (defined __PS3__ || defined __ORBIS__ || defined _DURANGO || defined __PSVITA__)
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)StorageManager.GetGameDefinedProfileData(m_iPad);
#else
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)ProfileManager.GetGameDefinedProfileData(m_iPad);
#endif
int arrayIndex = completableIndex >> 3;
int bitIndex = 7 - (completableIndex % 8);
pGameSettings->ucTutorialCompletion[arrayIndex] |= 1<<bitIndex;
// flag a profile write needed
pGameSettings->bSettingsChanged=true;
}
}
bool Tutorial::getCompleted( int completableId )
{
//if(app.GetGameSettingsDebugMask(m_iPad) && app.GetGameSettingsDebugMask()&(1L<<eDebugSetting_TipsAlwaysOn))
//{
// return false;
//}
int completableIndex = -1;
for( AUTO_VAR(it, s_completableTasks.begin()); it < s_completableTasks.end(); ++it)
{
++completableIndex;
if( *it == completableId )
{
break;
}
}
if( completableIndex >= 0 && completableIndex < TUTORIAL_PROFILE_STORAGE_BITS )
{
// Read the bit for this position
//Retrieve the data pointer from the profile
#if ( defined __PS3__ || defined __ORBIS__ || defined _DURANGO || defined __PSVITA__)
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)StorageManager.GetGameDefinedProfileData(m_iPad);
#else
GAME_SETTINGS *pGameSettings = (GAME_SETTINGS *)ProfileManager.GetGameDefinedProfileData(m_iPad);
#endif
int arrayIndex = completableIndex >> 3;
int bitIndex = 7 - (completableIndex % 8);
return (pGameSettings->ucTutorialCompletion[arrayIndex] & 1<<bitIndex) == (1<<bitIndex);
}
else
{
return false;
}
}
bool Tutorial::isStateCompleted( eTutorial_State state )
{
return getCompleted(state);
}
void Tutorial::setStateCompleted( eTutorial_State state )
{
setCompleted( state );
}
bool Tutorial::isHintCompleted( eTutorial_Hint hint )
{
return getCompleted(hint);
}
void Tutorial::setHintCompleted( eTutorial_Hint hint )
{
//if(app.GetGameSettingsDebugMask(m_iPad) && app.GetGameSettingsDebugMask()&(1L<<eDebugSetting_TipsAlwaysOn))
//{
// return;
//}
setCompleted( hint );
}
void Tutorial::setHintCompleted( TutorialHint *hint )
{
//if(app.GetGameSettingsDebugMask(m_iPad) && app.GetGameSettingsDebugMask()&(1L<<eDebugSetting_TipsAlwaysOn))
//{
// return;
//}
eTutorial_Hint hintId = hint->getId();
if( hintId != e_Tutorial_Hint_Always_On )
{
setHintCompleted( hint->getId() );
hints[m_CurrentState].erase( find(hints[m_CurrentState].begin(), hints[m_CurrentState].end(), hint) );
delete hint;
}
// else
// {
// find(hints[m_CurrentState].begin(), hints[m_CurrentState].end(), hint);
// }
}
void Tutorial::tick()
{
// Don't do anything for the first 2 seconds so that the loading screen is gone
if(!m_bHasTickedOnce)
{
int time = GetTickCount();
if(m_firstTickTime == 0)
{
m_firstTickTime = time;
}
else if ( time - m_firstTickTime > 1500 )
{
m_bHasTickedOnce = true;
}
}
if(!m_bHasTickedOnce)
{
return;
}
bool constraintChanged = false;
bool taskChanged = false;
for(unsigned int state = 0; state < e_Tutorial_State_Max; ++state)
{
AUTO_VAR(it, constraintsToRemove[state].begin());
while(it < constraintsToRemove[state].end() )
{
++(*it).second;
if( (*it).second > m_iTutorialConstraintDelayRemoveTicks )
{
TutorialConstraint *c = (*it).first;
constraints[state].erase( find( constraints[state].begin(), constraints[state].end(), c) );
c->setQueuedForRemoval(false);
it = constraintsToRemove[state].erase( it );
if( c->getDeleteOnDeactivate() )
{
delete c;
}
}
else
{
++it;
}
}
}
// 4J Stu TODO - Make this a constraint
Minecraft *pMinecraft = Minecraft::GetInstance();
if(m_freezeTime && !m_timeFrozen && !m_fullTutorialComplete )
{
// Need to set the time on both levels to stop the flickering as the local level
// tries to predict the time
MinecraftServer::SetTimeOfDay(m_iTutorialFreezeTimeValue);
pMinecraft->level->setDayTime(m_iTutorialFreezeTimeValue); // Always daytime
app.SetGameHostOption(eGameHostOption_DoDaylightCycle,0);
m_timeFrozen = true;
}
else if(m_freezeTime && m_timeFrozen && m_fullTutorialComplete)
{
MinecraftServer::SetTimeOfDay(m_iTutorialFreezeTimeValue);
pMinecraft->level->setDayTime(m_iTutorialFreezeTimeValue);
app.SetGameHostOption(eGameHostOption_DoDaylightCycle,1);
m_timeFrozen = false;
}
if(!m_allowShow)
{
if( currentTask[m_CurrentState] != NULL && (!currentTask[m_CurrentState]->AllowFade() || (lastMessageTime + m_iTutorialDisplayMessageTime ) > GetTickCount() ) )
{
uiTempDisabled = true;
}
ui.SetTutorialVisible( m_iPad, false );
return;
}
if(!hasRequestedUI )
{
#ifdef _XBOX
m_bSceneIsSplitscreen=app.GetLocalPlayerCount()>1;
if(m_bSceneIsSplitscreen)
{
app.NavigateToScene(m_iPad, eUIComponent_TutorialPopup,(void *)this, false, false, &m_hTutorialScene);
}
else
{
app.NavigateToScene(m_iPad, eUIComponent_TutorialPopup,(void *)this, false, false, &m_hTutorialScene);
}
#else
ui.SetTutorial(m_iPad, this);
#endif
hasRequestedUI = true;
}
else
{
// if we've changed mode, we may need to change scene
if(m_bSceneIsSplitscreen!=(app.GetLocalPlayerCount()>1))
{
#ifdef _XBOX
app.TutorialSceneNavigateBack(m_iPad);
m_bSceneIsSplitscreen=app.GetLocalPlayerCount()>1;
if(m_bSceneIsSplitscreen)
{
app.NavigateToScene(m_iPad, eUIComponent_TutorialPopup,(void *)this, false, false, &m_hTutorialScene);
}
else
{
app.NavigateToScene(m_iPad, eUIComponent_TutorialPopup,(void *)this, false, false, &m_hTutorialScene);
}
#else
ui.SetTutorial(m_iPad, this);
#endif
}
}
if(ui.IsPauseMenuDisplayed( m_iPad ) )
{
if( currentTask[m_CurrentState] != NULL && (!currentTask[m_CurrentState]->AllowFade() || (lastMessageTime + m_iTutorialDisplayMessageTime ) > GetTickCount() ) )
{
uiTempDisabled = true;
}
ui.SetTutorialVisible( m_iPad, false );
return;
}
if( uiTempDisabled )
{
ui.SetTutorialVisible( m_iPad, true );
lastMessageTime = GetTickCount();
uiTempDisabled = false;
}
// Check constraints
for(AUTO_VAR(it, m_globalConstraints.begin()); it < m_globalConstraints.end(); ++it)
{
TutorialConstraint *constraint = *it;
constraint->tick(m_iPad);
}
// Check hints
int hintNeeded = -1;
if(!m_hintDisplayed)
{
// 4J Stu - TU-1 interim
// Allow turning off all the hints
bool hintsOn = m_isFullTutorial || app.GetGameSettings(m_iPad,eGameSetting_Hints);
if(hintsOn)
{
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->tick();
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
message->m_allowFade = hint->allowFade();
message->m_forceDisplay = true;
setMessage( hint, message );
break;
}
}
}
}
// Check constraints
// Only need to update these if we aren't already failing something
if( !m_allTutorialsComplete && (currentFailedConstraint[m_CurrentState] == NULL || currentFailedConstraint[m_CurrentState]->isConstraintSatisfied(m_iPad)) )
{
if( currentFailedConstraint[m_CurrentState] != NULL && currentFailedConstraint[m_CurrentState]->isConstraintSatisfied(m_iPad) )
{
constraintChanged = true;
currentFailedConstraint[m_CurrentState] = NULL;
}
for(AUTO_VAR(it, constraints[m_CurrentState].begin()); it < constraints[m_CurrentState].end(); ++it)
{
TutorialConstraint *constraint = *it;
if( !constraint->isConstraintSatisfied(m_iPad) && constraint->isConstraintRestrictive(m_iPad) )
{
constraintChanged = true;
currentFailedConstraint[m_CurrentState] = constraint;
}
}
}
if( !m_allTutorialsComplete && currentFailedConstraint[m_CurrentState] == NULL )
{
// Update tasks
bool isCurrentTask = true;
AUTO_VAR(it, activeTasks[m_CurrentState].begin());
while(activeTasks[m_CurrentState].size() > 0 && it < activeTasks[m_CurrentState].end())
{
TutorialTask *task = *it;
if( isCurrentTask || task->isPreCompletionEnabled() )
{
isCurrentTask = false;
if(
( !task->ShowMinimumTime() || ( task->hasBeenActivated() && (lastMessageTime + m_iTutorialMinimumDisplayMessageTime ) < GetTickCount() ) )
&& task->isCompleted()
)
{
eTutorial_CompletionAction compAction = task->getCompletionAction();
it = activeTasks[m_CurrentState].erase( it );
delete task;
task = NULL;
if( activeTasks[m_CurrentState].size() > 0 )
{
switch( compAction )
{
case e_Tutorial_Completion_Complete_State_Gameplay_Constraints:
{
// 4J Stu - Move the delayed constraints to the gameplay state so that they are in
// effect for a bit longer
AUTO_VAR(itCon, constraintsToRemove[m_CurrentState].begin());
while(itCon != constraintsToRemove[m_CurrentState].end() )
{
constraints[e_Tutorial_State_Gameplay].push_back(itCon->first);
constraintsToRemove[e_Tutorial_State_Gameplay].push_back( pair<TutorialConstraint *, unsigned char>(itCon->first, itCon->second) );
constraints[m_CurrentState].erase( find( constraints[m_CurrentState].begin(), constraints[m_CurrentState].end(), itCon->first) );
itCon = constraintsToRemove[m_CurrentState].erase(itCon);
}
}
// Fall through the the normal complete state
case e_Tutorial_Completion_Complete_State:
for(AUTO_VAR(itRem, activeTasks[m_CurrentState].begin()); itRem < activeTasks[m_CurrentState].end(); ++itRem)
{
delete (*itRem);
}
activeTasks[m_CurrentState].clear();
break;
case e_Tutorial_Completion_Jump_To_Last_Task:
{
TutorialTask *lastTask = activeTasks[m_CurrentState].at( activeTasks[m_CurrentState].size() - 1 );
activeTasks[m_CurrentState].pop_back();
for(AUTO_VAR(itRem, activeTasks[m_CurrentState].begin()); itRem < activeTasks[m_CurrentState].end(); ++itRem)
{
delete (*itRem);
}
activeTasks[m_CurrentState].clear();
activeTasks[m_CurrentState].push_back( lastTask );
it = activeTasks[m_CurrentState].begin();
}
break;
case e_Tutorial_Completion_None:
default:
break;
}
}
if( activeTasks[m_CurrentState].size() > 0 )
{
currentTask[m_CurrentState] = activeTasks[m_CurrentState][0];
currentTask[m_CurrentState]->setAsCurrentTask();
}
else
{
setStateCompleted( m_CurrentState );
currentTask[m_CurrentState] = NULL;
}
taskChanged = true;
// If we can complete this early, check if we can complete it right now
if( currentTask[m_CurrentState] != NULL && currentTask[m_CurrentState]->isPreCompletionEnabled() )
{
isCurrentTask = true;
}
}
else
{
++it;
}
if( task != NULL && task->ShowMinimumTime() && task->hasBeenActivated() && (lastMessageTime + m_iTutorialMinimumDisplayMessageTime ) < GetTickCount() )
{
task->setShownForMinimumTime();
if( !m_hintDisplayed )
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = task->getDescriptionId();
message->m_promptId = task->getPromptId();
message->m_allowFade = task->AllowFade();
message->m_replaceCurrent = true;
setMessage( message );
}
}
}
else
{
++it;
}
}
if( currentTask[m_CurrentState] == NULL && activeTasks[m_CurrentState].size() > 0 )
{
currentTask[m_CurrentState] = activeTasks[m_CurrentState][0];
currentTask[m_CurrentState]->setAsCurrentTask();
taskChanged = true;
}
}
if(!m_allTutorialsComplete && (taskChanged || m_hasStateChanged) )
{
bool allComplete = true;
for(unsigned int state = 0; state < e_Tutorial_State_Max; ++state)
{
if(activeTasks[state].size() > 0 )
{
allComplete = false;
break;
}
if(state==e_Tutorial_State_Gameplay)
{
m_fullTutorialComplete = true;
Minecraft::GetInstance()->playerLeftTutorial(m_iPad);
}
}
if(allComplete)
m_allTutorialsComplete = true;
}
if( constraintChanged || taskChanged || m_hasStateChanged ||
(currentFailedConstraint[m_CurrentState] == NULL && currentTask[m_CurrentState] != NULL && (m_lastMessage == NULL || currentTask[m_CurrentState]->getDescriptionId() != m_lastMessage->m_messageId) && !m_hintDisplayed)
)
{
if( currentFailedConstraint[m_CurrentState] != NULL )
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = currentFailedConstraint[m_CurrentState]->getDescriptionId();
message->m_allowFade = false;
setMessage( message );
}
else if( currentTask[m_CurrentState] != NULL )
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = currentTask[m_CurrentState]->getDescriptionId();
message->m_promptId = currentTask[m_CurrentState]->getPromptId();
message->m_allowFade = currentTask[m_CurrentState]->AllowFade();
setMessage( message );
currentTask[m_CurrentState]->TaskReminders()? m_iTaskReminders = 1 : m_iTaskReminders = 0;
}
else
{
setMessage( NULL );
}
}
if(m_hintDisplayed && (lastMessageTime + m_iTutorialDisplayMessageTime ) < GetTickCount() )
{
m_hintDisplayed = false;
}
if( currentFailedConstraint[m_CurrentState] == NULL && currentTask[m_CurrentState] != NULL && (m_iTaskReminders!=0) && (lastMessageTime + (m_iTaskReminders * m_iTutorialReminderTime) ) < GetTickCount() )
{
// Reminder
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = currentTask[m_CurrentState]->getDescriptionId();
message->m_promptId = currentTask[m_CurrentState]->getPromptId();
message->m_allowFade = currentTask[m_CurrentState]->AllowFade();
message->m_isReminder = true;
setMessage( message );
++m_iTaskReminders;
if( m_iTaskReminders > 1 )
m_iTaskReminders = 1;
}
m_hasStateChanged = false;
// If we have completed this state, and it is one that occurs during normal gameplay then change back to the gameplay track
if( m_CurrentState != e_Tutorial_State_Gameplay && activeTasks[m_CurrentState].size() == 0 && (isSelectedItemState() || !ui.GetMenuDisplayed(m_iPad) ) )
{
this->changeTutorialState( e_Tutorial_State_Gameplay );
}
}
bool Tutorial::setMessage(PopupMessageDetails *message)
{
if(message != NULL && !message->m_forceDisplay &&
m_lastMessageState == m_CurrentState &&
message->isSameContent(m_lastMessage) &&
( !message->m_isReminder || ( (lastMessageTime + m_iTutorialReminderTime ) > GetTickCount() && message->m_isReminder ) )
)
{
delete message;
return false;
}
if(message != NULL && (message->m_messageId > 0 || !message->m_messageString.empty()) )
{
m_lastMessageState = m_CurrentState;
if(!message->m_replaceCurrent) lastMessageTime = GetTickCount();
wstring text;
if(!message->m_messageString.empty())
{
text = message->m_messageString;
}
else
{
AUTO_VAR(it, messages.find(message->m_messageId));
if( it != messages.end() && it->second != NULL )
{
TutorialMessage *messageString = it->second;
text = wstring( messageString->getMessageForDisplay() );
// 4J Stu - Quick fix for boat tutorial being incorrect
if(message->m_messageId == IDS_TUTORIAL_TASK_BOAT_OVERVIEW)
{
text = replaceAll(text, L"{*CONTROLLER_ACTION_USE*}", L"{*CONTROLLER_ACTION_DISMOUNT*}");
}
}
else
{
text = wstring( app.GetString(message->m_messageId) );
// 4J Stu - Quick fix for boat tutorial being incorrect
if(message->m_messageId == IDS_TUTORIAL_TASK_BOAT_OVERVIEW)
{
text = replaceAll(text, L"{*CONTROLLER_ACTION_USE*}", L"{*CONTROLLER_ACTION_DISMOUNT*}");
}
}
}
if(!message->m_promptString.empty())
{
text.append(message->m_promptString);
}
else if(message->m_promptId >= 0)
{
AUTO_VAR(it, messages.find(message->m_promptId));
if(it != messages.end() && it->second != NULL)
{
TutorialMessage *prompt = it->second;
text.append( prompt->getMessageForDisplay() );
}
}
wstring title;
TutorialPopupInfo popupInfo;
popupInfo.interactScene = m_UIScene;
popupInfo.desc = text.c_str();
popupInfo.icon = message->m_icon;
popupInfo.iAuxVal = message->m_iAuxVal;
popupInfo.allowFade = message->m_allowFade;
popupInfo.isReminder = message->m_isReminder;
popupInfo.tutorial = this;
if( !message->m_titleString.empty() || message->m_titleId > 0 )
{
if(message->m_titleString.empty()) title = wstring( app.GetString(message->m_titleId) );
else title = message->m_titleString;
popupInfo.title = title.c_str();
ui.SetTutorialDescription( m_iPad, &popupInfo );
}
else
{
ui.SetTutorialDescription( m_iPad, &popupInfo );
}
}
else if( (m_lastMessage != NULL && m_lastMessage->m_messageId != -1) ) //&& (lastMessageTime + m_iTutorialReminderTime ) > GetTickCount() )
{
// This should cause the popup to dissappear
TutorialPopupInfo popupInfo;
popupInfo.interactScene = m_UIScene;
popupInfo.tutorial = this;
ui.SetTutorialDescription( m_iPad, &popupInfo );
}
if(m_lastMessage != NULL) delete m_lastMessage;
m_lastMessage = message;
return true;
}
bool Tutorial::setMessage(TutorialHint *hint, PopupMessageDetails *message)
{
// 4J Stu - TU-1 interim
// Allow turning off all the hints
bool hintsOn = m_isFullTutorial || (app.GetGameSettings(m_iPad,eGameSetting_Hints) && app.GetGameSettings(m_iPad,eGameSetting_DisplayHUD));
bool messageShown = false;
DWORD time = GetTickCount();
if(message != NULL && (message->m_forceDisplay || hintsOn) &&
(!message->m_delay ||
(
(m_hintDisplayed && (time - m_lastHintDisplayedTime) > m_iTutorialHintDelayTime ) ||
(!m_hintDisplayed && (time - lastMessageTime) > m_iTutorialMinimumDisplayMessageTime )
)
)
)
{
messageShown = setMessage( message );
if(messageShown)
{
m_lastHintDisplayedTime = time;
m_hintDisplayed = true;
if(hint!=NULL) setHintCompleted( hint );
}
}
return messageShown;
}
bool Tutorial::setMessage(const wstring &messageString, int icon, int auxValue)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageString = messageString;
message->m_icon = icon;
message->m_iAuxVal = auxValue;
message->m_forceDisplay = true;
return setMessage(message);
}
void Tutorial::showTutorialPopup(bool show)
{
m_allowShow = show;
if(!show)
{
if( currentTask[m_CurrentState] != NULL && (!currentTask[m_CurrentState]->AllowFade() || (lastMessageTime + m_iTutorialDisplayMessageTime ) > GetTickCount() ) )
{
uiTempDisabled = true;
}
ui.SetTutorialVisible( m_iPad, show );
}
}
void Tutorial::useItemOn(Level *level, shared_ptr<ItemInstance> item, int x, int y, int z, bool bTestUseOnly)
{
for(AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it < activeTasks[m_CurrentState].end(); ++it)
{
TutorialTask *task = *it;
task->useItemOn(level, item, x, y, z, bTestUseOnly);
}
}
void Tutorial::useItemOn(shared_ptr<ItemInstance> item, bool bTestUseOnly)
{
for(AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it < activeTasks[m_CurrentState].end(); ++it)
{
TutorialTask *task = *it;
task->useItem(item, bTestUseOnly);
}
}
void Tutorial::completeUsingItem(shared_ptr<ItemInstance> item)
{
for(AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it < activeTasks[m_CurrentState].end(); ++it)
{
TutorialTask *task = *it;
task->completeUsingItem(item);
}
// Fix for #46922 - TU5: UI: Player receives a reminder that he is hungry while "hunger bar" is full (triggered in split-screen mode)
if(m_CurrentState != e_Tutorial_State_Gameplay)
{
for(AUTO_VAR(it, activeTasks[e_Tutorial_State_Gameplay].begin()); it < activeTasks[e_Tutorial_State_Gameplay].end(); ++it)
{
TutorialTask *task = *it;
task->completeUsingItem(item);
}
}
}
void Tutorial::startDestroyBlock(shared_ptr<ItemInstance> item, Tile *tile)
{
int hintNeeded = -1;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->startDestroyBlock(item, tile);
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
setMessage( hint, message );
break;
}
}
}
void Tutorial::destroyBlock(Tile *tile)
{
int hintNeeded = -1;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->destroyBlock(tile);
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
setMessage( hint, message );
break;
}
}
}
void Tutorial::attack(shared_ptr<Player> player, shared_ptr<Entity> entity)
{
int hintNeeded = -1;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->attack(player->inventory->getSelected(), entity);
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
setMessage( hint, message );
break;
}
}
}
void Tutorial::itemDamaged(shared_ptr<ItemInstance> item)
{
int hintNeeded = -1;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->itemDamaged(item);
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
setMessage( hint, message );
break;
}
}
}
void Tutorial::handleUIInput(int iAction)
{
if( m_hintDisplayed ) return;
//for(AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it < activeTasks[m_CurrentState].end(); ++it)
//{
// TutorialTask *task = *it;
// task->handleUIInput(iAction);
//}
if(currentTask[m_CurrentState] != NULL)
currentTask[m_CurrentState]->handleUIInput(iAction);
}
void Tutorial::createItemSelected(shared_ptr<ItemInstance> item, bool canMake)
{
int hintNeeded = -1;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->createItemSelected(item, canMake);
if(hintNeeded >= 0)
{
PopupMessageDetails *message = new PopupMessageDetails();
message->m_messageId = hintNeeded;
setMessage( hint, message );
break;
}
}
}
void Tutorial::onCrafted(shared_ptr<ItemInstance> item)
{
for(unsigned int state = 0; state < e_Tutorial_State_Max; ++state)
{
for(AUTO_VAR(it, activeTasks[state].begin()); it < activeTasks[state].end(); ++it)
{
TutorialTask *task = *it;
task->onCrafted(item);
}
}
}
void Tutorial::onTake(shared_ptr<ItemInstance> item, unsigned int invItemCountAnyAux, unsigned int invItemCountThisAux)
{
if( !m_hintDisplayed )
{
bool hintNeeded = false;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->onTake(item);
if(hintNeeded)
{
break;
}
}
}
for(unsigned int state = 0; state < e_Tutorial_State_Max; ++state)
{
for(AUTO_VAR(it, activeTasks[state].begin()); it < activeTasks[state].end(); ++it)
{
TutorialTask *task = *it;
task->onTake(item, invItemCountAnyAux, invItemCountThisAux);
}
}
}
void Tutorial::onSelectedItemChanged(shared_ptr<ItemInstance> item)
{
// We only handle this if we are in a state that allows changing based on the selected item
// Menus and states like riding in a minecart will NOT allow this
if( isSelectedItemState() )
{
if(item != NULL)
{
switch(item->id)
{
case Item::fishingRod_Id:
changeTutorialState(e_Tutorial_State_Fishing);
break;
default:
changeTutorialState(e_Tutorial_State_Gameplay);
break;
}
}
else
{
changeTutorialState(e_Tutorial_State_Gameplay);
}
}
}
void Tutorial::onLookAt(int id, int iData)
{
if( m_hintDisplayed ) return;
bool hintNeeded = false;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->onLookAt(id, iData);
if(hintNeeded)
{
break;
}
}
if( m_CurrentState == e_Tutorial_State_Gameplay )
{
if(id > 0)
{
switch(id)
{
case Tile::bed_Id:
changeTutorialState(e_Tutorial_State_Bed);
break;
default:
break;
}
}
}
}
void Tutorial::onLookAtEntity(shared_ptr<Entity> entity)
{
if( m_hintDisplayed ) return;
bool hintNeeded = false;
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->onLookAtEntity(entity->GetType());
if(hintNeeded)
{
break;
}
}
if ( (m_CurrentState == e_Tutorial_State_Gameplay) && entity->instanceof(eTYPE_HORSE) )
{
changeTutorialState(e_Tutorial_State_Horse);
}
for (AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it != activeTasks[m_CurrentState].end(); ++it)
{
(*it)->onLookAtEntity(entity);
}
}
void Tutorial::onRideEntity(shared_ptr<Entity> entity)
{
if(m_CurrentState == e_Tutorial_State_Gameplay)
{
switch (entity->GetType())
{
case eTYPE_MINECART: changeTutorialState(e_Tutorial_State_Riding_Minecart); break;
case eTYPE_BOAT: changeTutorialState(e_Tutorial_State_Riding_Boat); break;
}
}
for (AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it != activeTasks[m_CurrentState].end(); ++it)
{
(*it)->onRideEntity(entity);
}
}
void Tutorial::onEffectChanged(MobEffect *effect, bool bRemoved)
{
for(AUTO_VAR(it, activeTasks[m_CurrentState].begin()); it < activeTasks[m_CurrentState].end(); ++it)
{
TutorialTask *task = *it;
task->onEffectChanged(effect,bRemoved);
}
}
bool Tutorial::canMoveToPosition(double xo, double yo, double zo, double xt, double yt, double zt)
{
bool allowed = true;
for(AUTO_VAR(it, constraints[m_CurrentState].begin()); it < constraints[m_CurrentState].end(); ++it)
{
TutorialConstraint *constraint = *it;
if( !constraint->isConstraintSatisfied(m_iPad) && !constraint->canMoveToPosition(xo,yo,zo,xt,yt,zt) )
{
allowed = false;
break;
}
}
return allowed;
}
bool Tutorial::isInputAllowed(int mapping)
{
if( m_hintDisplayed ) return true;
// If the player is under water then allow all keypresses so they can jump out
if( Minecraft::GetInstance()->localplayers[m_iPad]->isUnderLiquid(Material::water) ) return true;
bool allowed = true;
for(AUTO_VAR(it, constraints[m_CurrentState].begin()); it < constraints[m_CurrentState].end(); ++it)
{
TutorialConstraint *constraint = *it;
if( constraint->isMappingConstrained( m_iPad, mapping ) )
{
allowed = false;
break;
}
}
return allowed;
}
vector<TutorialTask *> *Tutorial::getTasks()
{
return &tasks;
}
unsigned int Tutorial::getCurrentTaskIndex()
{
unsigned int index = 0;
for(AUTO_VAR(it, tasks.begin()); it < tasks.end(); ++it)
{
if(*it == currentTask[e_Tutorial_State_Gameplay])
break;
++index;
}
return index;
}
void Tutorial::AddGlobalConstraint(TutorialConstraint *c)
{
m_globalConstraints.push_back(c);
}
void Tutorial::AddConstraint(TutorialConstraint *c)
{
constraints[m_CurrentState].push_back(c);
}
void Tutorial::RemoveConstraint(TutorialConstraint *c, bool delayedRemove /*= false*/)
{
if( currentFailedConstraint[m_CurrentState] == c )
currentFailedConstraint[m_CurrentState] = NULL;
if( c->getQueuedForRemoval() )
{
// If it is already queued for removal, remove it on the next tick
/*for(AUTO_VAR(it, constraintsToRemove[m_CurrentState].begin()); it < constraintsToRemove[m_CurrentState].end(); ++it)
{
if( it->first == c )
{
it->second = m_iTutorialConstraintDelayRemoveTicks;
break;
}
}*/
}
else if(delayedRemove)
{
c->setQueuedForRemoval(true);
constraintsToRemove[m_CurrentState].push_back( pair<TutorialConstraint *, unsigned char>(c, 0) );
}
else
{
for( AUTO_VAR(it, constraintsToRemove[m_CurrentState].begin()); it < constraintsToRemove[m_CurrentState].end(); ++it)
{
if( it->first == c )
{
constraintsToRemove[m_CurrentState].erase( it );
break;
}
}
AUTO_VAR(it, find( constraints[m_CurrentState].begin(), constraints[m_CurrentState].end(), c));
if( it != constraints[m_CurrentState].end() ) constraints[m_CurrentState].erase( find( constraints[m_CurrentState].begin(), constraints[m_CurrentState].end(), c) );
// It may be in the gameplay list, so remove it from there if it is
it = find( constraints[e_Tutorial_State_Gameplay].begin(), constraints[e_Tutorial_State_Gameplay].end(), c);
if( it != constraints[e_Tutorial_State_Gameplay].end() ) constraints[e_Tutorial_State_Gameplay].erase( find( constraints[e_Tutorial_State_Gameplay].begin(), constraints[e_Tutorial_State_Gameplay].end(), c) );
}
}
void Tutorial::addTask(eTutorial_State state, TutorialTask *t)
{
if( state == e_Tutorial_State_Gameplay )
{
tasks.push_back(t);
}
activeTasks[state].push_back(t);
}
void Tutorial::addHint(eTutorial_State state, TutorialHint *h)
{
hints[state].push_back(h);
}
void Tutorial::addMessage(int messageId, bool limitRepeats /*= false*/, unsigned char numRepeats /*= TUTORIAL_MESSAGE_DEFAULT_SHOW*/)
{
if(messageId >= 0 && messages.find(messageId)==messages.end())
messages[messageId] = new TutorialMessage(messageId, limitRepeats, numRepeats);
}
#ifdef _XBOX
void Tutorial::changeTutorialState(eTutorial_State newState, CXuiScene *scene /*= NULL*/)
#else
void Tutorial::changeTutorialState(eTutorial_State newState, UIScene *scene /*= NULL*/)
#endif
{
if(newState == m_CurrentState)
{
// If clearing the scene, make sure that the tutorial popup has its reference to this scene removed
#ifndef _XBOX
if( scene == NULL )
{
ui.RemoveInteractSceneReference(m_iPad, m_UIScene);
}
#endif
m_UIScene = scene;
return;
}
// 4J Stu - TU-1 interim
// Allow turning off all the hints
bool hintsOn = m_isFullTutorial || app.GetGameSettings(m_iPad,eGameSetting_Hints);
if(hintsOn)
{
// If we have completed this state, and it is one that occurs during normal gameplay then change back to the gameplay track
if( newState != e_Tutorial_State_Gameplay && activeTasks[newState].size() == 0 && !ui.GetMenuDisplayed(m_iPad) )
{
return;
}
// The action that caused the change of state may also have completed the current task
if( currentTask[m_CurrentState] != NULL && currentTask[m_CurrentState]->isCompleted() )
{
activeTasks[m_CurrentState].erase( find( activeTasks[m_CurrentState].begin(), activeTasks[m_CurrentState].end(), currentTask[m_CurrentState]) );
if( activeTasks[m_CurrentState].size() > 0 )
{
currentTask[m_CurrentState] = activeTasks[m_CurrentState][0];
currentTask[m_CurrentState]->setAsCurrentTask();
}
else
{
currentTask[m_CurrentState] = NULL;
}
}
if( currentTask[m_CurrentState] != NULL )
{
currentTask[m_CurrentState]->onStateChange(newState);
}
// Make sure that the current message is cleared
setMessage( NULL );
// If clearing the scene, make sure that the tutorial popup has its reference to this scene removed
#ifndef _XBOX
if( scene == NULL )
{
ui.RemoveInteractSceneReference(m_iPad, m_UIScene);
}
#endif
m_UIScene = scene;
if( m_CurrentState != newState )
{
for(AUTO_VAR(it, activeTasks[newState].begin()); it < activeTasks[newState].end(); ++it)
{
TutorialTask *task = *it;
task->onStateChange(newState);
}
m_CurrentState = newState;
m_hasStateChanged = true;
m_hintDisplayed = false;
}
}
}
bool Tutorial::isSelectedItemState()
{
bool isSelectedItemState = false;
switch(m_CurrentState)
{
case e_Tutorial_State_Gameplay:
case e_Tutorial_State_Fishing:
isSelectedItemState = true;
break;
default:
break;
}
return isSelectedItemState;
}
Reference in New Issue View Git Blame Copy Permalink