TickingAreas unload periodically, causing the chunk(s) to stop simulating for a moment
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In 
, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In the picture below, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
Steps to Reproduce
- Open tick_testing.mcworld
. It contains a scoreboard system that counts ticks in several chunks simulated by the player, and in ticking area. - /tp -89 1 -128
- Flip the lever.
- Wait for a few minutes, or up to an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Linked Issues
relates to4
MCPE-40601Repeating Command Blocks randomly not working as intended.Cannot ReproduceMCPE-73059droppers don't work in ticking area IncompleteMCPE-109263/tickingarea sets a ticking area to a chunk near the specified coordinates instead of being set to it, and Y coordinates is always set to 0ConfirmedMCPE-99760Permanent, non removable ticking areas created with minecraft:tick_world componentCannot Reproduce
Created Issue:
TickingAreas unload periodically, causing the chunk(s) to stop simulating for a moment
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears to be directly proportional to the size of the tickingArea, and when they fail it affects every chunk in that area.
Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the image, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
Attachments2
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears t
o be directly proportional to the size of the tickingArea, and when they fail it affects every chunk in that area.Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:
{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the image, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the first image, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In the second image, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the
first image, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.In t
he second image, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the tick_testing.png, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
![[Mod] GoldenHelmet](../../../data/avatars/users/18951.svg){kind=small}
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Proof
Download the .mcworld file linked. Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea, both of which should be ticking every gametick.
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the tick_testing.png, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Steps to Reproduce
- Open tick_testing.mcworld
This code also shows that tickingAreas are separate from the player:{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the tick_testing.png, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
Steps to Reproduce
- Open tick_testing.mcworld
This code also shows that tickingAreas are separate from the player:
{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}In the tick_testing.png, the first value is how many gameticks have been simulated in the tickingArea over the course of an hour. The second value is how many gameticks have been simulated by the player over the same time frame.
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{{color:#00875a}public{color}: {color:#00875a}void{color} __cdecl {color:#0747a6}ChunkLoadActionList::onStaticTickingAreaAdded{color}(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class {color:#de350b}std{color}::basic_string<{color:#00875a}char{color},struct {color:#de350b}std{color}::{color:#172b4d}char{color}_traits<{color:#00875a}char{color}>,class {color:#de350b}std{color}::allocator<{color:#00875a}char{color}> > {color:#00875a}const{color} & __ptr64) __ptr64 {color:#00875a}public{color}: {color:#00875a}virtual enum{color} EventResult __cdecl {color:#0747a6}PlayerEventListener::onPlayerTick{color}(class Player & __ptr64) __ptr64 }}
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In tick_testing_2.png, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{{color:#00875a}public{color}: {color:#00875a}void{color} __cdecl {color:#0747a6}ChunkLoadActionList::onStaticTickingAreaAdded{color}(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class {color:#de350b}std{color}::basic_string<{color:#00875a}char{color},struct {color:#de350b}std{color}::{color:#172b4d}char{color}_traits<{color:#00875a}char{color}>,class {color:#de350b}std{color}::allocator<{color:#00875a}char{color}> > {color:#00875a}const{color} & __ptr64) __ptr64 {color:#00875a}public{color}: {color:#00875a}virtual enum{color} EventResult __cdecl {color:#0747a6}PlayerEventListener::onPlayerTick{color}(class Player & __ptr64) __ptr64 }}TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{{color:#00875a}public{color}: {color:#00875a}void{color} __cdecl {color:#0747a6}ChunkLoadActionList::onStaticTickingAreaAdded{color}(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class {color:#de350b}std{color}::basic_string<{color:#00875a}char{color},struct {color:#de350b}std{color}::{color:#172b4d}char{color}_traits<{color:#00875a}char{color}>,class {color:#de350b}std{color}::allocator<{color:#00875a}char{color}> > {color:#00875a}const{color} & __ptr64) __ptr64 {color:#00875a}public{color}: {color:#00875a}virtual enum{color} EventResult __cdecl {color:#0747a6}PlayerEventListener::onPlayerTick{color}(class Player & __ptr64) __ptr64 }}
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:{{{color:#00875a}public{color}: {color:#00875a}void{color} __cdecl {color:#0747a6}ChunkLoadActionList::onStaticTickingAreaAdded{color}(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class {color:#de350b}std{color}::basic_string<{color:#00875a}char{color},struct {color:#de350b}std{color}::{color:#172b4d}char{color}_traits<{color:#00875a}char{color}>,class {color:#de350b}std{color}::allocator<{color:#00875a}char{color}> > {color:#00875a}const{color} & __ptr64) __ptr64 {color:#00875a}public{color}: {color:#00875a}virtual enum{color} EventResult __cdecl {color:#0747a6}PlayerEventListener::onPlayerTick{color}(class Player & __ptr64) __ptr64 }}TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In the picture below, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In the picture below, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait for a few minutes, or up to an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}
![[MCQA] v-weszaj](../../../data/avatars/users/18941.svg){kind=small}
TickingAreas don't tick reliably which could be a huge problem for technical maps/Marketplace content that require command blocks to function.
It appears that larger tickingAreas unload more frequently, and when they fail it affects every chunk in that area. More testing needs to be done in order to confirm this, though.
In
In the picture below, the chunks labelled chunk[_] are separate chunks in the same tickingArea. This is evidence that larger tickingAreas unload more often.
Steps to Reproduce
- Open tick_testing.mcworld
- /tp -89 1 -128
- Flip the lever.
- Wait for a few minutes, or up to an hour.
Expected result
All scoreboards display the same number.
Actual result
Areas simulated by the player have a higher value on the scoreboard than that of the tickingArea.
Code analysis:
This code also shows that tickingAreas are simulated separately from the chunks simulated around players:
{{public: void __cdecl ChunkLoadActionList::onStaticTickingAreaAdded(class ServerLevel & __ptr64,class LevelStorage & __ptr64,class Dimension & __ptr64,class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const & __ptr64) __ptr64
public: virtual enum EventResult __cdecl PlayerEventListener::onPlayerTick(class Player & __ptr64) __ptr64
}}
relates to
![[Mod] OcelotOnesie](../../../data/avatars/users/43220.png){kind=small}
I had tried to reproduce this with the pack from MCPE-48138 using /kill @e, and could not reproduce. However, I do wonder if MCPE-119312 could cause this to occur randomly.
The first set of repro steps in the description here would not be valid b/c they require using a 3rd-party world editor. However, the second set of steps might be reproducible by deactivating a behavior pack.
I reproduced this running the test world for <10 minutes while updating the ticket. By 10,000 ticks there was a noticeable difference.
The problems described in
MCPE-40601andMCPE-73059may have been partially due to this issue.Can confirm this happens in singleplayer and with BDS
Code Analysis (BDS 1.16.100): The code analysis in the report is incorrect. Those two functions are not responsible for ticking chunks.
`TickingAreaView::tick()` is the important function to pay attention to. This is the function that gets called every game tick to tick all the chunks in a ticking area. There is a bool flag passed to `TickingAreaView::tick()`, and that function does something different depending on whether the flag is TRUE or FALSE. I believe it's this flag that is responsible for chunks in ticking areas sometimes not ticking.
`TickingAreaListBase::tick()` ticks all the ticking areas in a dimension and is responsible for setting the flag that gets passed to `TickingAreaView::tick()`. For each ticking area, this flag is true once every 20 ticks, but not all ticking areas will have the flag set at the same time. (I'm simplifying here.)
When the flag is false, all chunks in the ticking area appear to be ticked normally. When the flag is true, the ticks seem to be getting ticked in a random order, or only a random subset get ticked. But I'm not quite sure of this.
My best guess is that ticking areas are supposed to work like this, but in practice they do not:
(1) Every tick: Tick all chunks in ticking area.
(2) Every 20 ticks, randomize the order of chunks in the ticking area.
Removed the inaccurate and incomplete "Code Analysis". Sorry for any confusion.