phaneron/smartcmd-MinecraftConsoles
1
0
Fork 0
mirror of https://github.com/smartcmd/MinecraftConsoles.git synced 2026-05-18 14:53:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: TU19 (Dec 2014) Features & Content (#155)

Browse source 
* 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>
This commit is contained in:
daoge 2026-03-03 03:04:10 +08:00 • committed by GitHub
parent 84c31a2331
commit b3feddfef3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
2069 changed files with 264842 additions and 139522 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Minecraft.Client/Common/Tutorial/DiggerItemHint.cpp
View file

@ -62,7 +62,7 @@ int DiggerItemHint::attack(shared_ptr<ItemInstance> item, shared_ptr<Entity> ent
if(itemFound)
{
// It's also possible that we could hit TileEntities (eg falling sand) so don't want to give this hint then
if( dynamic_pointer_cast<Mob>( entity ) != NULL )
if( entity->instanceof(eTYPE_MOB) )
{
return IDS_TUTORIAL_HINT_ATTACK_WITH_TOOL;
}

75
Minecraft.Client/Common/Tutorial/FullTutorial.cpp
View file

@ -140,7 +140,7 @@ FullTutorial::FullTutorial(int iPad, bool isTrial /*= false*/)
int pickaxeAuxVals[] = {-1,-1,-1,-1,-1};
addTask(e_Tutorial_State_Gameplay, new CraftTask( pickaxeItems, pickaxeAuxVals, 5, 1, this, IDS_TUTORIAL_TASK_CREATE_WOODEN_PICKAXE) );
addTask(e_Tutorial_State_Gameplay, new PickupTask( Tile::stoneBrick_Id, 8, -1, this, IDS_TUTORIAL_TASK_MINE_STONE ) );
addTask(e_Tutorial_State_Gameplay, new PickupTask( Tile::cobblestone_Id, 8, -1, this, IDS_TUTORIAL_TASK_MINE_STONE ) );
addTask(e_Tutorial_State_Gameplay, new ProgressFlagTask( &m_progressFlags, FULL_TUTORIAL_PROGRESS_CRAFT_FURNACE, ProgressFlagTask::e_Progress_Set_Flag, this ) );
addTask(e_Tutorial_State_Gameplay, new CraftTask( Tile::furnace_Id, -1, 1, this, IDS_TUTORIAL_TASK_CREATE_FURNACE ) );
@ -522,8 +522,8 @@ FullTutorial::FullTutorial(int iPad, bool isTrial /*= false*/)
AABB *area = app.getGameRuleDefinitions()->getNamedArea(L"tradingArea");
if(area != NULL)
{
eTutorial_State enchantingStates[] = {e_Tutorial_State_Gameplay};
AddGlobalConstraint( new ChangeStateConstraint(this, e_Tutorial_State_Trading, enchantingStates, 1, area->x0,area->y0,area->z0,area->x1,area->y1,area->z1) );
eTutorial_State tradingStates[] = {e_Tutorial_State_Gameplay};
AddGlobalConstraint( new ChangeStateConstraint(this, e_Tutorial_State_Trading, tradingStates, 1, area->x0,area->y0,area->z0,area->x1,area->y1,area->z1) );
addTask(e_Tutorial_State_Trading, new ChoiceTask(this, IDS_TUTORIAL_TASK_TRADING_OVERVIEW, IDS_TUTORIAL_PROMPT_TRADING_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Trading) );
@ -535,6 +535,75 @@ FullTutorial::FullTutorial(int iPad, bool isTrial /*= false*/)
}
}
/*
*
*
* FIREWORKS
*
*/
if(app.getGameRuleDefinitions() != NULL)
{
AABB *area = app.getGameRuleDefinitions()->getNamedArea(L"fireworksArea");
if(area != NULL)
{
eTutorial_State fireworkStates[] = {e_Tutorial_State_Gameplay};
AddGlobalConstraint( new ChangeStateConstraint(this, e_Tutorial_State_Fireworks, fireworkStates, 1, area->x0,area->y0,area->z0,area->x1,area->y1,area->z1) );
addTask(e_Tutorial_State_Fireworks, new ChoiceTask(this, IDS_TUTORIAL_TASK_FIREWORK_OVERVIEW, IDS_TUTORIAL_PROMPT_FIREWORK_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Trading) );
addTask(e_Tutorial_State_Fireworks, new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_PURPOSE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Fireworks, new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_CUSTOMISE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) ); //
addTask(e_Tutorial_State_Fireworks, new InfoTask(this, IDS_TUTORIAL_TASK_FIREWORK_CRAFTING, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
}
/*
*
*
* BEACON
*
*/
if(app.getGameRuleDefinitions() != NULL)
{
AABB *area = app.getGameRuleDefinitions()->getNamedArea(L"beaconArea");
if(area != NULL)
{
eTutorial_State beaconStates[] = {e_Tutorial_State_Gameplay};
AddGlobalConstraint( new ChangeStateConstraint(this, e_Tutorial_State_Beacon, beaconStates, 1, area->x0,area->y0,area->z0,area->x1,area->y1,area->z1) );
addTask(e_Tutorial_State_Beacon, new ChoiceTask(this, IDS_TUTORIAL_TASK_BEACON_OVERVIEW, IDS_TUTORIAL_PROMPT_BEACON_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Beacon) );
addTask(e_Tutorial_State_Beacon, new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_PURPOSE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Beacon, new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_DESIGN, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Beacon, new InfoTask(this, IDS_TUTORIAL_TASK_BEACON_CHOOSING_POWERS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
}
/*
*
*
* HOPPER
*
*/
if(app.getGameRuleDefinitions() != NULL)
{
AABB *area = app.getGameRuleDefinitions()->getNamedArea(L"hopperArea");
if(area != NULL)
{
eTutorial_State hopperStates[] = {e_Tutorial_State_Gameplay};
AddGlobalConstraint( new ChangeStateConstraint(this, e_Tutorial_State_Hopper, hopperStates, 1, area->x0,area->y0,area->z0,area->x1,area->y1,area->z1) );
addTask(e_Tutorial_State_Hopper, new ChoiceTask(this, IDS_TUTORIAL_TASK_HOPPER_OVERVIEW, IDS_TUTORIAL_PROMPT_HOPPER_OVERVIEW, true, ACTION_MENU_A, ACTION_MENU_B, e_Tutorial_Completion_Complete_State_Gameplay_Constraints, eTelemetryTutorial_Hopper) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_PURPOSE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_CONTAINERS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_MECHANICS, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_REDSTONE, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_OUTPUT, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
addTask(e_Tutorial_State_Hopper, new InfoTask(this, IDS_TUTORIAL_TASK_HOPPER_AREA, IDS_TUTORIAL_PROMPT_PRESS_A_TO_CONTINUE, true, ACTION_MENU_A) );
}
}
/*
*
*

43
Minecraft.Client/Common/Tutorial/HorseChoiceTask.cpp Normal file
View file

@ -0,0 +1,43 @@
#include "stdafx.h"
#include <string>
#include "Minecraft.h"
#include "Tutorial.h"
#include "..\Minecraft.World\EntityHorse.h"
#include "HorseChoiceTask.h"
HorseChoiceTask::HorseChoiceTask(Tutorial *tutorial, int iDescHorse, int iDescDonkey, int iDescMule, int iPromptId,
bool requiresUserInput, int iConfirmMapping, int iCancelMapping,
eTutorial_CompletionAction cancelAction, ETelemetryChallenges telemetryEvent)
: ChoiceTask(tutorial, -1, iPromptId, requiresUserInput, iConfirmMapping, iCancelMapping, cancelAction, telemetryEvent)
{
m_eHorseType = -1;
m_iDescMule = iDescMule;
m_iDescDonkey = iDescDonkey;
m_iDescHorse = iDescHorse;
}
int HorseChoiceTask::getDescriptionId()
{
switch (m_eHorseType)
{
case EntityHorse::TYPE_HORSE: return m_iDescHorse;
case EntityHorse::TYPE_DONKEY: return m_iDescDonkey;
case EntityHorse::TYPE_MULE: return m_iDescMule;
default: return -1;
}
return -1;
}
void HorseChoiceTask::onLookAtEntity(shared_ptr<Entity> entity)
{
if ( (m_eHorseType < 0) && entity->instanceof(eTYPE_HORSE) )
{
shared_ptr<EntityHorse> horse = dynamic_pointer_cast<EntityHorse>(entity);
if ( horse->isAdult() ) m_eHorseType = horse->getType();
}
}

23
Minecraft.Client/Common/Tutorial/HorseChoiceTask.h Normal file
View file

@ -0,0 +1,23 @@
#pragma once
using namespace std;
#include "ChoiceTask.h"
// Same as choice task, but switches description based on horse type.
class HorseChoiceTask : public ChoiceTask
{
protected:
int m_eHorseType;
int m_iDescHorse, m_iDescDonkey, m_iDescMule;
public:
HorseChoiceTask(Tutorial *tutorial, int iDescHorse, int iDescDonkey, int iDescMule, int iPromptId = -1,
bool requiresUserInput = false, int iConfirmMapping = 0, int iCancelMapping = 0,
eTutorial_CompletionAction cancelAction = e_Tutorial_Completion_None, ETelemetryChallenges telemetryEvent = eTelemetryChallenges_Unknown);
virtual int getDescriptionId();
virtual void onLookAtEntity(shared_ptr<Entity> entity);
};

12
Minecraft.Client/Common/Tutorial/LookAtTileHint.cpp
View file

@ -50,15 +50,11 @@ bool LookAtTileHint::onLookAt(int id,int iData)
else
{
message->m_icon = id;
if(m_iDataOverride > -1)
{
message->m_iAuxVal = m_iDataOverride;
}
else
{
message->m_iAuxVal = iData;
}
}
// 4J-JEV: Moved to keep data override even if we're overriding the icon as well.
message->m_iAuxVal = (m_iDataOverride > -1) ? m_iDataOverride : iData;
message->m_messageId = Item::items[id]->getUseDescriptionId();
message->m_titleId = Item::items[id]->getDescriptionId(message->m_iAuxVal);
return m_tutorial->setMessage(this, message);

30
Minecraft.Client/Common/Tutorial/RideEntityTask.cpp Normal file
View file

@ -0,0 +1,30 @@
#include "stdafx.h"
#include <string>
#include "Minecraft.h"
#include "Tutorial.h"
#include "..\Minecraft.World\EntityHorse.h"
#include "RideEntityTask.h"
RideEntityTask::RideEntityTask(const int eType, Tutorial *tutorial, int descriptionId,
bool enablePreCompletion, vector<TutorialConstraint *> *inConstraints, bool bShowMinimumTime, bool bAllowFade, bool bTaskReminders)
: TutorialTask( tutorial, descriptionId, enablePreCompletion, inConstraints, bShowMinimumTime, bAllowFade, bTaskReminders ),
m_eType( eType )
{
}
bool RideEntityTask::isCompleted()
{
return bIsCompleted;
}
void RideEntityTask::onRideEntity(shared_ptr<Entity> entity)
{
if (entity->instanceof((eINSTANCEOF) m_eType))
{
bIsCompleted = true;
}
}

22
Minecraft.Client/Common/Tutorial/RideEntityTask.h Normal file
View file

@ -0,0 +1,22 @@
#pragma once
using namespace std;
#include "TutorialTask.h"
class Level;
// 4J-JEV: Tasks that involve riding an entity.
class RideEntityTask : public TutorialTask
{
protected:
const int m_eType;
public:
RideEntityTask(const int eTYPE, Tutorial *tutorial, int descriptionId,
bool enablePreCompletion = false, vector<TutorialConstraint *> *inConstraints = NULL,
bool bShowMinimumTime = false, bool bAllowFade = true, bool bTaskReminders = true );
virtual bool isCompleted();
virtual void onRideEntity(shared_ptr<Entity> entity);
};

258
Minecraft.Client/Common/Tutorial/Tutorial.cpp
View file

@ -289,9 +289,9 @@ void Tutorial::staticCtor()
s_completableTasks.push_back( e_Tutorial_Hint_Potato );
s_completableTasks.push_back( e_Tutorial_Hint_Carrot );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Unused_18 );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Unused_19 );
s_completableTasks.push_back( e_Tutorial_Hint_Item_Unused_20 );
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 );
@ -317,9 +317,31 @@ void Tutorial::staticCtor()
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_State_Unused_9 );
s_completableTasks.push_back( e_Tutorial_State_Unused_10 );
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 )
{
@ -376,10 +398,10 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
/*
* TILE HINTS
*/
int rockItems[] = {Tile::rock_Id};
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::stoneBrick_Id};
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};
@ -438,7 +460,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Sandstone, this, sandstoneItems, 1, -1, SandStoneTile::TYPE_SMOOTHSIDE ) );
}
int noteBlockItems[] = {Tile::musicBlock_Id};
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};
@ -455,13 +477,13 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
addHint(e_Tutorial_State_Gameplay, new LookAtTileHint(e_Tutorial_Hint_Tall_Grass, this, tallGrassItems, 1, -1, TallGrass::FERN ) );
}
int woolItems[] = {Tile::cloth_Id};
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::mushroom1_Id, Tile::mushroom2_Id};
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};
@ -499,7 +521,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::mossStone_Id};
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};
@ -526,7 +548,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::crops_Id};
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};
@ -544,7 +566,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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_stoneBrickSmooth_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};
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};
@ -562,7 +584,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::notGate_off_Id, Tile::notGate_on_Id};
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};
@ -583,19 +605,19 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::recordPlayer_Id};
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::hellRock_Id};
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::hellSand_Id};
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::lightGem_Id};
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};
@ -608,7 +630,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::diode_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 ) );
@ -622,10 +644,10 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::stoneBrickSmooth_Id};
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::hugeMushroom1_Id,Tile::hugeMushroom2_Id};
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};
@ -673,7 +695,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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::whiteStone_Id};
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};
@ -683,7 +705,7 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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 ) );
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 ) );
@ -734,6 +756,45 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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
@ -760,8 +821,12 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
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_OZELOT ) );
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) );
/*
@ -929,6 +994,86 @@ Tutorial::Tutorial(int iPad, bool isFullTutorial /*= false*/) : m_iPad( iPad )
}
// 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 );
}
/*
*
*
@ -1203,27 +1348,15 @@ void Tutorial::tick()
// 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->setOverrideTimeOfDay(m_iTutorialFreezeTimeValue); // Always daytime
pMinecraft->level->setDayTime(m_iTutorialFreezeTimeValue); // Always daytime
app.SetGameHostOption(eGameHostOption_DoDaylightCycle,0);
m_timeFrozen = true;
}
else if(m_freezeTime && m_timeFrozen && m_fullTutorialComplete)
{
__int64 currentTime = pMinecraft->level->getTime();
int currentDayTime = (currentTime % Level::TICKS_PER_DAY);
int timeToAdd = 0;
if(currentDayTime > m_iTutorialFreezeTimeValue)
{
timeToAdd = (Level::TICKS_PER_DAY - currentDayTime) + m_iTutorialFreezeTimeValue;
}
else
{
timeToAdd = m_iTutorialFreezeTimeValue - currentDayTime;
}
__int64 targetTime = currentTime + timeToAdd;
MinecraftServer::SetTimeOfDay(-1);
MinecraftServer::SetTime(targetTime);
pMinecraft->level->setOverrideTimeOfDay(-1);
pMinecraft->level->setTime(targetTime);
MinecraftServer::SetTimeOfDay(m_iTutorialFreezeTimeValue);
pMinecraft->level->setDayTime(m_iTutorialFreezeTimeValue);
app.SetGameHostOption(eGameHostOption_DoDaylightCycle,1);
m_timeFrozen = false;
}
@ -1569,10 +1702,22 @@ bool Tutorial::setMessage(PopupMessageDetails *message)
{
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*}");
}
}
}
@ -1916,7 +2061,7 @@ void Tutorial::onLookAt(int id, int iData)
}
}
void Tutorial::onLookAtEntity(eINSTANCEOF type)
void Tutorial::onLookAtEntity(shared_ptr<Entity> entity)
{
if( m_hintDisplayed ) return;
@ -1924,12 +2069,39 @@ void Tutorial::onLookAtEntity(eINSTANCEOF type)
for(AUTO_VAR(it, hints[m_CurrentState].begin()); it < hints[m_CurrentState].end(); ++it)
{
TutorialHint *hint = *it;
hintNeeded = hint->onLookAtEntity(type);
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)

3
Minecraft.Client/Common/Tutorial/Tutorial.h
View file

@ -165,7 +165,8 @@ public:
void onTake(shared_ptr<ItemInstance> item, unsigned int invItemCountAnyAux, unsigned int invItemCountThisAux);
void onSelectedItemChanged(shared_ptr<ItemInstance> item);
void onLookAt(int id, int iData=0);
void onLookAtEntity(eINSTANCEOF type);
void onLookAtEntity(shared_ptr<Entity> entity);
void onRideEntity(shared_ptr<Entity> entity);
void onEffectChanged(MobEffect *effect, bool bRemoved=false);
bool canMoveToPosition(double xo, double yo, double zo, double xt, double yt, double zt);

32
Minecraft.Client/Common/Tutorial/TutorialEnum.h
View file

@ -62,9 +62,14 @@ enum eTutorial_State
e_Tutorial_State_Anvil,
e_Tutorial_State_Anvil_Menu,
e_Tutorial_State_Enderchests,
e_Tutorial_State_Unused_9,
e_Tutorial_State_Unused_10,
e_Tutorial_State_Horse,
e_Tutorial_State_Horse_Menu,
e_Tutorial_State_Hopper,
e_Tutorial_State_Hopper_Menu,
e_Tutorial_State_Beacon,
e_Tutorial_State_Beacon_Menu,
e_Tutorial_State_Fireworks,
e_Tutorial_State_Fireworks_Menu,
e_Tutorial_State_Max
};
@ -201,9 +206,12 @@ enum eTutorial_Hint
e_Tutorial_Hint_EnderDragon,
e_Tutorial_Hint_Blaze,
e_Tutorial_Hint_Lava_Slime,
e_Tutorial_Hint_Ozelot,
e_Tutorial_Hint_Villager,
e_Tutorial_Hint_Wither,
e_Tutorial_Hint_Witch,
e_Tutorial_Hint_Bat,
e_Tutorial_Hint_Horse,
e_Tutorial_Hint_Item_Shovel,
e_Tutorial_Hint_Item_Hatchet,
@ -292,9 +300,19 @@ enum eTutorial_Hint
e_Tutorial_Hint_Potato,
e_Tutorial_Hint_Carrot,
e_Tutorial_Hint_Item_Unused_18,
e_Tutorial_Hint_Item_Unused_19,
e_Tutorial_Hint_Item_Unused_20,
e_Tutorial_Hint_CommandBlock,
e_Tutorial_Hint_Beacon,
e_Tutorial_Hint_Activator_Rail,
e_Tutorial_Hint_RedstoneBlock,
e_Tutorial_Hint_DaylightDetector,
e_Tutorial_Hint_Dropper,
e_Tutorial_Hint_Hopper,
e_Tutorial_Hint_Comparator,
e_Tutorial_Hint_ChestTrap,
e_Tutorial_Hint_HayBlock,
e_Tutorial_Hint_ClayHardened,
e_Tutorial_Hint_ClayHardenedColored,
e_Tutorial_Hint_CoalBlock,
e_Tutorial_Hint_Item_Max,
};

6
Minecraft.Client/Common/Tutorial/TutorialTask.h
View file

@ -6,6 +6,7 @@ class Level;
class Tutorial;
class TutorialConstraint;
class MobEffect;
class Entity;
// A class that represents each individual task in the tutorial.
//
@ -33,7 +34,7 @@ protected:
vector<TutorialConstraint *> constraints;
bool areConstraintsEnabled;
public:
TutorialTask(Tutorial *tutorial, int descriptionId, bool enablePreCompletion, vector<TutorialConstraint *> *inConstraints, bool bShowMinimumTime=false, bool bAllowFade=true, bool m_bTaskReminders=true );
TutorialTask(Tutorial *tutorial, int descriptionId, bool enablePreCompletion, vector<TutorialConstraint *> *inConstraints, bool bShowMinimumTime=false, bool bAllowFade=true, bool bTaskReminders=true );
virtual ~TutorialTask();
virtual int getDescriptionId() { return descriptionId; }
@ -60,4 +61,7 @@ public:
virtual void onTake(shared_ptr<ItemInstance> item, unsigned int invItemCountAnyAux, unsigned int invItemCountThisAux) { }
virtual void onStateChange(eTutorial_State newState) { }
virtual void onEffectChanged(MobEffect *effect, bool bRemoved=false) { }
virtual void onLookAtEntity(shared_ptr<Entity> entity) { }
virtual void onRideEntity(shared_ptr<Entity> entity) { }
};

2
Minecraft.Client/Common/Tutorial/TutorialTasks.h
View file

@ -9,6 +9,8 @@
#include "XuiCraftingTask.h"
#include "StateChangeTask.h"
#include "ChoiceTask.h"
#include "HorseChoiceTask.h"
#include "RideEntityTask.h"
#include "FullTutorialActiveTask.h"
#include "AreaTask.h"
#include "ProgressFlagTask.h"

1
Minecraft.Client/Common/Tutorial/UseItemTask.h
View file

@ -10,7 +10,6 @@ class UseItemTask : public TutorialTask
{
private:
const int itemId;
bool completed;
public:
UseItemTask(const int itemId, Tutorial *tutorial, int descriptionId,