[1.9][SOLVED]Tile entity being replaced

[horsewithnoname]

Hello people!

 

I have a problem with tile entities being replaced, which is cause the whole execution to go nuts (because of the local data that not stored on the disk).

 

There's the code:

 

/* Package and Imports */

public class DirectorMapTileEntity extends AbstractDirectorTileEntity
{
    /**
     * Temporary map of actor entities during playback. This map is used
     * to determine if the registered actors are still playing their roles.
     */
    protected Map<String, ActorEntity> actorMap = new HashMap<String, ActorEntity>();

    @Override
    public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newSate)
    {
        return false;
    }

    /**
     * Add a replay string to list of actors
     */
    public boolean add(String replay)
    {
        if (!this.actors.contains(replay))
        {
            this.actors.add(replay);
            this.markDirty();

            return true;
        }

        return false;
    }

    /**
     * Starts a playback
     *
     * This method is different from the method in DirectorTileEntity, instead
     * of finding all entities and making them play, this method is basically
     * do the same thing as CommandPlay#execute, launching the playback
     * and adding new created entity to actors map.
     */
    @Override
    public void startPlayback()
    {
        if (this.isPlaying())
        {
            return;
        }

        for (String replay : this.actors)
        {
            String[] splits = replay.split(":");
            Entity entity = null;

            if (splits.length == 2)
            {
                entity = Mocap.startPlayback(splits[0], splits[0], splits[1], this.worldObj, true);
            }
            else if (splits.length == 1)
            {
                entity = Mocap.startPlayback(splits[0], splits[0], splits[0], this.worldObj, true);
            }

            this.actorMap.put(replay, (ActorEntity) entity);
        }

        this.playBlock(true);
    }

    /**
     * Does what it says to do – checking if the actors still playing their
     * roles (not finished playback).
     */
    @Override
    protected void areActorsStillPlaying()
    {
        int count = 0;

        for (String replay : this.actors)
        {
            if (Mocap.playbacks.containsKey(this.actorMap.get(replay)))
            {
                count++;
            }
        }

        System.out.println(this + " " + this.worldObj.isRemote);

        if (count == 0)
        {
            this.playBlock(false);
            this.actorMap.clear();
        }
    }
}

 

Basically, this TE is responsible for checking if actor entities are still playing and when they'll finish playing to shutdown the operation, basically to switch block's state and switch direction of redstone circuit.

 

As you can see from the code and the log below, when areActorsStillPlaying is called first, everything is ok, but on the next call it's being replaced (I make this assumption based on the class's address change). The local hash map in this TE is really important, but I don't understand why it's being replaced...

 

I tried to return false in shouldRefresh() to avoid replacing of this TE, but it didn't worked.

 

There's the log:

 

 

[22:21:59] [server thread/INFO]: [@: 14 blocks cloned]

[22:21:59] [server thread/INFO]: [@: Killed Pig]

[22:21:59] [Client thread/INFO]: [CHAT] [@: 14 blocks cloned]

[22:21:59] [Client thread/INFO]: [CHAT] [@: Killed Pig]

[22:22:03] [server thread/INFO] [sTDOUT]: [noname.blockbuster.tileentity.DirectorMapTileEntity:areActorsStillPlaying:106]: noname.blockbuster.tileentity.DirectorMapTileEntity@2177e71b false

[22:22:03] [server thread/INFO] [sTDOUT]: [noname.blockbuster.tileentity.DirectorMapTileEntity:areActorsStillPlaying:106]: noname.blockbuster.tileentity.DirectorMapTileEntity@1dfe0901 false

[22:22:03] [server thread/INFO]: [@: Object successfully summoned]

[22:22:03] [Client thread/INFO]: [CHAT] [@: Object successfully summoned]

[22:22:12] [Playback Thread/INFO] [sTDOUT]: [noname.blockbuster.recording.PlayThread:run:78]: Replay thread completed.

[22:22:14] [server thread/INFO]: Saving and pausing game...

 

 

How to fix that behavior?

 

Thank you for attention!

 

Edit: is there possibility that it's happens because my actor entities are like 80 blocks away? Because those actor entities in playback can be located really far.

[jeffryfisher]

This is an old problem going back to 1.8 or earlier. There's a default behavior that replaces the TE for any state change, no matter how minor. Override shouldRefrsh, but you don't want to return a simple false. There really are many cases in which you do want the TE to be replaced, so test for them.

 

PS: Never forget that when you hit a snag, Google is your friend.

[horsewithnoname]

I solved my problem, and it turned out that the problem wasn't in TE's being replaced. The problem actually was in the wrong storage of block's data.

 

I stored the playing state in block's public boolean field (because I was lazy to write additional code for block's metadata). In the log, there's two messages with two different objects being replaced, but in reality there was two different TE for two different blocks that I didn't noticed.

 

So, the glitch happened because these two TE's were attached to the same block instance with public boolean field. When one of the TE's started playing, the other gets the same value of isPlaying as the initial TE.

 

Basically, now I learned that Block instances are kinda singletons (they're allocated and initiated only once), and now that I understand better Block. The solution was to rewrite block's class to store state in IBlockState, and get this state from TE's instead of directly from the Block's class.

 

[spoiler=Code]

public abstract class AbstractDirectorBlock extends Block implements ITileEntityProvider
{
    public static final PropertyBool PLAYING = PropertyBool.create("playing");

    /* States */

    @Override
    public int getMetaFromState(IBlockState state)
    {
        return state.getValue(PLAYING) ? 1 : 0;
    }

    @Override
    public IBlockState getStateFromMeta(int meta)
    {
        return this.getDefaultState().withProperty(PLAYING, meta == 1 ? true : false);
    }

    @Override
    protected BlockStateContainer createBlockState()
    {
        return new BlockStateContainer(this, new IProperty[] { PLAYING });
    }
    
    /* Other code */
}

public abstract class AbstractDirectorTileEntity extends TileEntity implements ITickable
{
    /**
     * Checks every 4 ticks if the actors (that registered by this TE) are
     * still playing their roles.
     */
    @Override
    public void update()
    {
        if (this.tick-- > 0 || !this.isPlaying())
        {
            return;
        }

        this.areActorsStillPlaying();
        this.tick = 4;
    }

    /**
     * Does what it says to do – checking if the actors still playing their
     * roles (not finished playback).
     */
    protected void areActorsStillPlaying()
    {
        int count = 0;

        for (String id : this.actors)
        {
            ActorEntity actor = (ActorEntity) Mocap.entityByUUID(this.worldObj, id);

            if (!Mocap.playbacks.containsKey(actor))
            {
                count++;
            }
        }

        if (count == this.actors.size())
        {
            this.playBlock(false);
        }
    }

    // Using block states instead of Block's public fields
    
    /**
     * Set the state of the block playing (needed to update redstone thingy-stuff)
     */
    protected void playBlock(boolean isPlaying)
    {
        this.worldObj.setBlockState(this.pos, this.worldObj.getBlockState(this.pos).withProperty(AbstractDirectorBlock.PLAYING, isPlaying));
    }

    /**
     * Checks if block's state isPlaying is true
     */
    protected boolean isPlaying()
    {
        return this.worldObj.getBlockState(this.pos).getValue(AbstractDirectorBlock.PLAYING);
    }
}

 

 

Sorry for misleading

 

P.S.: I probably deserve a -1 for misleading