file_name
stringlengths 6
86
| file_path
stringlengths 45
249
| content
stringlengths 47
6.26M
| file_size
int64 47
6.26M
| language
stringclasses 1
value | extension
stringclasses 1
value | repo_name
stringclasses 767
values | repo_stars
int64 8
14.4k
| repo_forks
int64 0
1.17k
| repo_open_issues
int64 0
788
| repo_created_at
stringclasses 767
values | repo_pushed_at
stringclasses 767
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
SceneLocation.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/SceneLocation.java | package mchorse.blockbuster.recording.scene;
import io.netty.buffer.ByteBuf;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import java.util.Objects;
/**
* Scene location data class
*
* This bad boy allows to unify director blocks and scene identifier into one structure
*/
public class SceneLocation
{
private Scene scene;
private String filename;
public SceneLocation()
{}
public SceneLocation(Scene scene)
{
this.scene = scene;
this.filename = scene.getId();
}
public SceneLocation(String filename)
{
this.filename = filename;
}
public Scene getScene()
{
return this.scene;
}
public String getFilename()
{
return this.filename;
}
public int getType()
{
return this.isEmpty() ? 0 : 1;
}
public boolean isEmpty()
{
return !this.isScene();
}
public boolean isScene()
{
return this.filename != null && !this.filename.isEmpty();
}
@Override
public boolean equals(Object obj)
{
if (obj instanceof SceneLocation)
{
SceneLocation location = (SceneLocation) obj;
if (this.getType() == location.getType())
{
return Objects.equals(this.filename, location.filename);
}
}
return super.equals(obj);
}
public SceneLocation copyEmpty()
{
if (this.isScene())
{
return new SceneLocation(this.getFilename());
}
return new SceneLocation();
}
public void fromByteBuf(ByteBuf buf)
{
this.filename = null;
if (buf.readBoolean())
{
this.filename = ByteBufUtils.readUTF8String(buf);
}
if (buf.readBoolean())
{
this.scene = this.isScene() ? new Scene() : null;
if (this.scene != null)
{
this.scene.fromBuf(buf);
}
}
}
public void toByteBuf(ByteBuf buf)
{
buf.writeBoolean(this.filename != null);
if (this.filename != null)
{
ByteBufUtils.writeUTF8String(buf, this.filename);
}
buf.writeBoolean(this.scene != null);
if (this.scene != null)
{
this.scene.toBuf(buf);
}
}
} | 2,362 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FakeChannel.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/fake/FakeChannel.java | package mchorse.blockbuster.recording.scene.fake;
import java.net.SocketAddress;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.Channel;
import io.netty.channel.ChannelConfig;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelMetadata;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.ChannelProgressivePromise;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import net.minecraft.network.NetworkManager;
import net.minecraftforge.fml.common.network.handshake.NetworkDispatcher;
import net.minecraftforge.fml.common.network.NetworkRegistry;
public class FakeChannel implements Channel{
private class FalseBool implements Attribute<Boolean>{
public AttributeKey<Boolean> key() {return null;}
public Boolean get() {return Boolean.valueOf(false);}
public void set(Boolean value) {}
public Boolean getAndSet(Boolean value) {return Boolean.valueOf(false);}
public Boolean setIfAbsent(Boolean value) {return Boolean.valueOf(false);}
public Boolean getAndRemove() {return Boolean.valueOf(false);}
public boolean compareAndSet(Boolean oldValue, Boolean newValue) {return false;}
public void remove(){}
}
@Override
public <T> Attribute<T> attr(AttributeKey<T> key)
{
if (key == NetworkDispatcher.FML_DISPATCHER)
{
return (Attribute<T>) new FakeFMLAttribute();
}
if (key == NetworkManager.PROTOCOL_ATTRIBUTE_KEY)
{
return (Attribute<T>) new FakeProtocol();
}
if (key == NetworkRegistry.FML_MARKER) {
return (Attribute<T>) new FalseBool();
}
return null;
}
@Override
public int compareTo(Channel o)
{
return 0;
}
@Override
public EventLoop eventLoop()
{
return null;
}
@Override
public Channel parent()
{
return null;
}
@Override
public ChannelConfig config()
{
return new FakeConfig();
}
@Override
public boolean isOpen()
{
return false;
}
@Override
public boolean isRegistered()
{
return false;
}
@Override
public boolean isActive()
{
return false;
}
@Override
public ChannelMetadata metadata()
{
return null;
}
@Override
public SocketAddress localAddress()
{
return null;
}
@Override
public SocketAddress remoteAddress()
{
return null;
}
@Override
public ChannelFuture closeFuture()
{
return null;
}
@Override
public boolean isWritable()
{
return false;
}
@Override
public Unsafe unsafe()
{
return null;
}
@Override
public ChannelPipeline pipeline()
{
return null;
}
@Override
public ByteBufAllocator alloc()
{
return null;
}
@Override
public ChannelPromise newPromise()
{
return null;
}
@Override
public ChannelProgressivePromise newProgressivePromise()
{
return null;
}
@Override
public ChannelFuture newSucceededFuture()
{
return null;
}
@Override
public ChannelFuture newFailedFuture(Throwable cause)
{
return null;
}
@Override
public ChannelPromise voidPromise()
{
return null;
}
@Override
public ChannelFuture bind(SocketAddress localAddress)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress)
{
return null;
}
@Override
public ChannelFuture disconnect()
{
return null;
}
@Override
public ChannelFuture close()
{
return null;
}
@Override
public ChannelFuture deregister()
{
return null;
}
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture disconnect(ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture close(ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture deregister(ChannelPromise promise)
{
return null;
}
@Override
public Channel read()
{
return null;
}
@Override
public ChannelFuture write(Object msg)
{
return null;
}
@Override
public ChannelFuture write(Object msg, ChannelPromise promise)
{
return null;
}
@Override
public Channel flush()
{
return null;
}
@Override
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture writeAndFlush(Object msg)
{
return null;
}
@Override
public <T> boolean hasAttr(AttributeKey<T> key)
{
return false;
}
@Override
public ChannelId id()
{
return null;
}
@Override
public long bytesBeforeUnwritable()
{
return 0;
}
@Override
public long bytesBeforeWritable()
{
return 0;
}
}
| 5,862 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FakeFMLAttribute.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/fake/FakeFMLAttribute.java | package mchorse.blockbuster.recording.scene.fake;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import net.minecraftforge.fml.common.network.handshake.NetworkDispatcher;
public class FakeFMLAttribute implements Attribute<NetworkDispatcher>
{
@Override
public AttributeKey<NetworkDispatcher> key()
{
return null;
}
@Override
public NetworkDispatcher get()
{
return null;
}
@Override
public void set(NetworkDispatcher value)
{}
@Override
public NetworkDispatcher getAndSet(NetworkDispatcher value)
{
return null;
}
@Override
public NetworkDispatcher setIfAbsent(NetworkDispatcher value)
{
return null;
}
@Override
public NetworkDispatcher getAndRemove()
{
return null;
}
@Override
public boolean compareAndSet(NetworkDispatcher oldValue, NetworkDispatcher newValue)
{
return false;
}
@Override
public void remove()
{}
} | 1,015 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FakeContext.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/fake/FakeContext.java | package mchorse.blockbuster.recording.scene.fake;
import java.net.SocketAddress;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.ChannelProgressivePromise;
import io.netty.channel.ChannelPromise;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.EventExecutor;
public class FakeContext implements ChannelHandlerContext
{
public Channel channel = new FakeChannel();
@Override
public <T> Attribute<T> attr(AttributeKey<T> key)
{
return null;
}
@Override
public Channel channel()
{
return new FakeChannel();
}
@Override
public EventExecutor executor()
{
return null;
}
@Override
public String name()
{
return null;
}
@Override
public ChannelHandler handler()
{
return null;
}
@Override
public boolean isRemoved()
{
return false;
}
@Override
public ChannelHandlerContext fireChannelRegistered()
{
return null;
}
@Override
public ChannelHandlerContext fireChannelUnregistered()
{
return null;
}
@Override
public ChannelHandlerContext fireChannelActive()
{
return null;
}
@Override
public ChannelHandlerContext fireChannelInactive()
{
return null;
}
@Override
public ChannelHandlerContext fireExceptionCaught(Throwable cause)
{
return null;
}
@Override
public ChannelHandlerContext fireUserEventTriggered(Object event)
{
return null;
}
@Override
public ChannelHandlerContext fireChannelRead(Object msg)
{
return null;
}
@Override
public ChannelHandlerContext fireChannelReadComplete()
{
return null;
}
@Override
public ChannelHandlerContext fireChannelWritabilityChanged()
{
return null;
}
@Override
public ChannelFuture bind(SocketAddress localAddress)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress)
{
return null;
}
@Override
public ChannelFuture disconnect()
{
return null;
}
@Override
public ChannelFuture close()
{
return null;
}
@Override
public ChannelFuture deregister()
{
return null;
}
@Override
public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture disconnect(ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture close(ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture deregister(ChannelPromise promise)
{
return null;
}
@Override
public ChannelHandlerContext read()
{
return null;
}
@Override
public ChannelFuture write(Object msg)
{
return null;
}
@Override
public ChannelFuture write(Object msg, ChannelPromise promise)
{
return null;
}
@Override
public ChannelHandlerContext flush()
{
return null;
}
@Override
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise)
{
return null;
}
@Override
public ChannelFuture writeAndFlush(Object msg)
{
return null;
}
@Override
public ChannelPipeline pipeline()
{
return null;
}
@Override
public ByteBufAllocator alloc()
{
return null;
}
@Override
public ChannelPromise newPromise()
{
return null;
}
@Override
public ChannelProgressivePromise newProgressivePromise()
{
return null;
}
@Override
public ChannelFuture newSucceededFuture()
{
return null;
}
@Override
public ChannelFuture newFailedFuture(Throwable cause)
{
return null;
}
@Override
public ChannelPromise voidPromise()
{
return null;
}
@Override
public <T> boolean hasAttr(AttributeKey<T> key)
{
return false;
}
} | 4,845 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FakeProtocol.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/fake/FakeProtocol.java | package mchorse.blockbuster.recording.scene.fake;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import net.minecraft.network.EnumConnectionState;
public class FakeProtocol implements Attribute<EnumConnectionState>
{
@Override
public AttributeKey<EnumConnectionState> key()
{
return null;
}
@Override
public EnumConnectionState get()
{
return null;
}
@Override
public void set(EnumConnectionState value)
{}
@Override
public EnumConnectionState getAndSet(EnumConnectionState value)
{
return null;
}
@Override
public EnumConnectionState setIfAbsent(EnumConnectionState value)
{
return null;
}
@Override
public EnumConnectionState getAndRemove()
{
return null;
}
@Override
public boolean compareAndSet(EnumConnectionState oldValue, EnumConnectionState newValue)
{
return false;
}
@Override
public void remove()
{}
} | 1,009 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FakeConfig.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/scene/fake/FakeConfig.java | package mchorse.blockbuster.recording.scene.fake;
import java.util.Map;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelConfig;
import io.netty.channel.ChannelOption;
import io.netty.channel.MessageSizeEstimator;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.channel.WriteBufferWaterMark;
public class FakeConfig implements ChannelConfig
{
@Override
public Map<ChannelOption<?>, Object> getOptions()
{
return null;
}
@Override
public boolean setOptions(Map<ChannelOption<?>, ?> options)
{
return false;
}
@Override
public <T> T getOption(ChannelOption<T> option)
{
return null;
}
@Override
public <T> boolean setOption(ChannelOption<T> option, T value)
{
return false;
}
@Override
public int getConnectTimeoutMillis()
{
return 0;
}
@Override
public ChannelConfig setConnectTimeoutMillis(int connectTimeoutMillis)
{
return null;
}
@Override
public int getMaxMessagesPerRead()
{
return 0;
}
@Override
public ChannelConfig setMaxMessagesPerRead(int maxMessagesPerRead)
{
return null;
}
@Override
public int getWriteSpinCount()
{
return 0;
}
@Override
public ChannelConfig setWriteSpinCount(int writeSpinCount)
{
return null;
}
@Override
public ByteBufAllocator getAllocator()
{
return null;
}
@Override
public ChannelConfig setAllocator(ByteBufAllocator allocator)
{
return null;
}
@Override
public RecvByteBufAllocator getRecvByteBufAllocator()
{
return null;
}
@Override
public ChannelConfig setRecvByteBufAllocator(RecvByteBufAllocator allocator)
{
return null;
}
@Override
public boolean isAutoRead()
{
return false;
}
@Override
public ChannelConfig setAutoRead(boolean autoRead)
{
return null;
}
@Override
public boolean isAutoClose()
{
return false;
}
@Override
public ChannelConfig setAutoClose(boolean autoClose)
{
return null;
}
@Override
public int getWriteBufferHighWaterMark()
{
return 0;
}
@Override
public ChannelConfig setWriteBufferHighWaterMark(int writeBufferHighWaterMark)
{
return null;
}
@Override
public int getWriteBufferLowWaterMark()
{
return 0;
}
@Override
public ChannelConfig setWriteBufferLowWaterMark(int writeBufferLowWaterMark)
{
return null;
}
@Override
public MessageSizeEstimator getMessageSizeEstimator()
{
return null;
}
@Override
public ChannelConfig setMessageSizeEstimator(MessageSizeEstimator estimator)
{
return null;
}
@Override
public WriteBufferWaterMark getWriteBufferWaterMark()
{
return null;
}
@Override
public ChannelConfig setWriteBufferWaterMark(WriteBufferWaterMark writeBufferWaterMark)
{
return null;
}
} | 3,148 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
WorldEventListener.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/WorldEventListener.java | package mchorse.blockbuster.recording.capturing;
import java.util.List;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.common.block.BlockDirector;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.BreakBlockAnimation;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.SoundEvent;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IWorldEventListener;
import net.minecraft.world.World;
/**
* Blockbuster's world event listener
*
* This dude is responsible only for adding breaking block animation during
* player recording.
*/
public class WorldEventListener implements IWorldEventListener
{
public World world;
public static void setBlockState(World world, BlockPos pos, IBlockState newState, int flags)
{
if (Blockbuster.damageControl.get())
{
ActionHandler.lastTE = world.getTileEntity(pos);
}
}
public WorldEventListener(World world)
{
this.world = world;
}
/**
* Used by damage control
*/
@Override
public void notifyBlockUpdate(World worldIn, BlockPos pos, IBlockState oldState, IBlockState newState, int flags)
{
if (Blockbuster.damageControl.get())
{
if (oldState.getBlock() instanceof BlockDirector)
{
return;
}
else if (oldState.getBlock() == Blocks.PISTON_EXTENSION)
{
oldState = Blocks.AIR.getDefaultState();
}
CommonProxy.damage.addBlock(pos, oldState, worldIn);
}
}
@Override
public void notifyLightSet(BlockPos pos)
{}
@Override
public void markBlockRangeForRenderUpdate(int x1, int y1, int z1, int x2, int y2, int z2)
{}
@Override
public void playSoundToAllNearExcept(EntityPlayer player, SoundEvent soundIn, SoundCategory category, double x, double y, double z, float volume, float pitch)
{}
@Override
public void playRecord(SoundEvent soundIn, BlockPos pos)
{}
@Override
public void spawnParticle(int particleID, boolean ignoreRange, double xCoord, double yCoord, double zCoord, double xSpeed, double ySpeed, double zSpeed, int... parameters)
{}
@Override
public void spawnParticle(int p_190570_1_, boolean p_190570_2_, boolean p_190570_3_, double p_190570_4_, double p_190570_6_, double p_190570_8_, double p_190570_10_, double p_190570_12_, double p_190570_14_, int... p_190570_16_)
{}
@Override
public void onEntityAdded(Entity entity)
{
if (entity instanceof EntityActor || entity instanceof EntityPlayer)
{
return;
}
CommonProxy.damage.addEntity(entity);
}
@Override
public void onEntityRemoved(Entity entityIn)
{}
@Override
public void broadcastSound(int soundID, BlockPos pos, int data)
{}
@Override
public void playEvent(EntityPlayer player, int type, BlockPos blockPosIn, int data)
{}
@Override
public void sendBlockBreakProgress(int breakerId, BlockPos pos, int progress)
{
Entity breaker = this.world.getEntityByID(breakerId);
if (breaker instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) breaker;
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new BreakBlockAnimation(pos, progress));
}
}
}
} | 3,831 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
FrameHandler.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/FrameHandler.java | package mchorse.blockbuster.recording.capturing;
import java.util.Objects;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.ClientProxy;
import mchorse.blockbuster.aperture.CameraHandler;
import mchorse.blockbuster.network.Dispatcher;
import mchorse.blockbuster.network.common.PacketDamageControlCheck;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.Phase;
import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
/**
* Frame handler
*
* This class is responsible for recording frames on the client side.
*/
@SideOnly(Side.CLIENT)
public class FrameHandler
{
private BlockPos last = null;
/**
* This is going to record the player actions
* and check DamageControl
*/
@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event)
{
EntityPlayer player = event.player;
if (event.phase == Phase.START)
{
return;
}
if (player.world.isRemote)
{
if (ClientProxy.manager.recorders.containsKey(player))
{
ClientProxy.manager.recorders.get(player).record(player);
}
if (Blockbuster.damageControlMessage.get() && !CameraHandler.isCameraEditorOpen())
{
if (Minecraft.getMinecraft().objectMouseOver != null)
{
BlockPos pos = Minecraft.getMinecraft().objectMouseOver.getBlockPos();
if (pos != null && !Objects.equals(last, pos))
{
Dispatcher.sendToServer(new PacketDamageControlCheck(pos));
}
last = pos;
}
else
{
last = null;
}
}
}
}
} | 2,160 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
PlayerTracker.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/PlayerTracker.java | package mchorse.blockbuster.recording.capturing;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.recording.RecordRecorder;
import mchorse.blockbuster.recording.actions.AttackAction;
import mchorse.blockbuster.recording.actions.CloseContainerAction;
import mchorse.blockbuster.recording.actions.EquipAction;
import mchorse.blockbuster.recording.actions.HotbarChangeAction;
import mchorse.blockbuster.recording.actions.SwipeAction;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.item.ItemStack;
import java.util.Arrays;
import java.util.List;
/**
* Player tracker class
*
* This class tracks player's properties such as arm swing and player equipped
* inventory. That's it.
*/
public class PlayerTracker
{
/**
* Record recorder to which tracked stuff are going to be added
*/
public RecordRecorder recorder;
/* Items to track */
private ItemStack[] items = new ItemStack[6];
private ItemStack[] hotbar = new ItemStack[9];
/**
* Runtime variable to track the complete hotbar for the fist frame
*/
private boolean trackedHotbar = false;
private Container container;
public PlayerTracker(RecordRecorder recorder)
{
this.recorder = recorder;
Arrays.fill(hotbar, ItemStack.EMPTY);
}
/**
* Track player's properties like armor, hand held items and hand swing
*/
public void track(EntityPlayer player)
{
this.trackSwing(player);
this.trackHeldItem(player);
this.trackHotBar(player);
this.trackArmor(player);
this.trackContainerClose(player);
}
/**
* Track armor inventory
*/
private void trackArmor(EntityPlayer player)
{
for (int i = 1; i < 5; i++)
{
this.trackItemToSlot(player.inventory.armorInventory.get(i - 1), i);
}
}
/**
* Track held items
*/
private void trackHeldItem(EntityPlayer player)
{
ItemStack mainhand = player.getHeldItemMainhand();
ItemStack offhand = player.getHeldItemOffhand();
this.trackItemToSlot(mainhand, 0, player.inventory.currentItem);
this.trackItemToSlot(offhand, 5);
}
private void trackHotBar(EntityPlayer player)
{
List<ItemStack> playerHotbar = player.inventory.mainInventory;
for (int i = 0; i < playerHotbar.size() && i < this.hotbar.length; i++)
{
if (!ItemStack.areItemStacksEqual(this.hotbar[i], playerHotbar.get(i)) || !this.trackedHotbar)
{
this.recorder.actions.add(new HotbarChangeAction(i, playerHotbar.get(i).copy()));
this.hotbar[i] = playerHotbar.get(i).copy();
}
}
this.trackedHotbar = true;
}
/**
* Track item to slot.
*
* This is a simple utility method that reduces number of lines for both
* hands.
*/
private boolean trackItemToSlot(ItemStack item, int slot)
{
return this.trackItemToSlot(item, slot, -1);
}
private boolean trackItemToSlot(ItemStack item, int slot, int hotbarslot)
{
if (!item.isEmpty())
{
if (item != this.items[slot])
{
this.items[slot] = item;
this.recorder.actions.add((hotbarslot != -1) ? new EquipAction((byte) slot,(byte) hotbarslot, item) : new EquipAction((byte) slot, item));
return true;
}
}
else if (this.items[slot] != null)
{
this.items[slot] = null;
this.recorder.actions.add((hotbarslot != -1) ? new EquipAction((byte) slot,(byte) hotbarslot, null) : new EquipAction((byte) slot, null));
return true;
}
return false;
}
/**
* Track the hand swing (like when you do the tap-tap with left-click)
*/
private void trackSwing(EntityPlayer player)
{
/**
* player.isPlayerSleeping() is necessary since for some reason when
* player is falling asleep, the isSwingInProgress is true, while
* player.swingProgress is equals to 0 which makes player swipe every
* tick in bed.
*
* So gotta check that so it wouldn't look like Steve is beating his
* meat.
*/
if (player.isSwingInProgress && player.swingProgress == 0 && !player.isPlayerSleeping())
{
this.recorder.actions.add(new SwipeAction());
if (Blockbuster.recordAttackOnSwipe.get())
{
this.recorder.actions.add(new AttackAction());
}
}
}
/**
* Track whether player has closed a container
*/
private void trackContainerClose(EntityPlayer player)
{
if (container != null && player.openContainer == player.inventoryContainer && container != player.openContainer)
{
this.recorder.actions.add(new CloseContainerAction());
}
this.container = player.openContainer;
}
} | 5,090 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
DamageControl.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/DamageControl.java | package mchorse.blockbuster.recording.capturing;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
/**
* Damage control
*
* This class is responsible for storing damaged blocks and be able to restore
* them in the world.
*/
public class DamageControl
{
public List<BlockEntry> blocks = new ArrayList<BlockEntry>();
public List<Entity> entities = new ArrayList<Entity>();
public EntityLivingBase target;
public int maxDistance;
public DamageControl(EntityLivingBase target, int maxDistance)
{
this.target = target;
this.maxDistance = maxDistance;
}
/**
* Add a block to damage control repository
*
* This method is responsible for adding only these blocks which are
* in the radius of allowed {@link #maxDistance} range. Max distance gets
* set from the config property {@link mchorse.blockbuster.Blockbuster#damageControlDistance}.
*/
public void addBlock(BlockPos pos, IBlockState state, World world)
{
double x = Math.abs(this.target.posX - pos.getX());
double y = Math.abs(this.target.posY - pos.getY());
double z = Math.abs(this.target.posZ - pos.getZ());
if (x > this.maxDistance || y > this.maxDistance || z > this.maxDistance)
{
return;
}
for (BlockEntry entry : this.blocks)
{
if (entry.pos.getX() == pos.getX() && entry.pos.getY() == pos.getY() && entry.pos.getZ() == pos.getZ())
{
return;
}
}
this.blocks.add(new BlockEntry(pos, state, ActionHandler.lastTE));
}
/**
* Apply recorded damaged blocks back in the world
*/
public void apply(World world)
{
for (BlockEntry entry : this.blocks)
{
world.setBlockState(entry.pos, entry.state);
if (entry.te != null)
{
world.setTileEntity(entry.pos, TileEntity.create(world, entry.te));
}
}
for (Entity entity : this.entities)
{
entity.setDead();
}
this.blocks.clear();
this.entities.clear();
}
/**
* Block entry in the damage control class
*
* This class holds information about destroyed block, such as it's state
*/
public static class BlockEntry
{
public BlockPos pos;
public IBlockState state;
public NBTTagCompound te;
public BlockEntry(BlockPos pos, IBlockState state, TileEntity te)
{
this.pos = pos;
this.state = state;
if (te != null)
{
this.te = te.writeToNBT(new NBTTagCompound());
}
}
}
} | 3,022 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ActionHandler.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/ActionHandler.java | package mchorse.blockbuster.recording.capturing;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.ClientProxy;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.capabilities.recording.IRecording;
import mchorse.blockbuster.capabilities.recording.Recording;
import mchorse.blockbuster.client.RenderingHandler;
import mchorse.blockbuster.client.SkinHandler;
import mchorse.blockbuster.client.render.tileentity.TileEntityGunItemStackRenderer;
import mchorse.blockbuster.client.render.tileentity.TileEntityGunItemStackRenderer.GunEntry;
import mchorse.blockbuster.client.render.tileentity.TileEntityModelItemStackRenderer;
import mchorse.blockbuster.client.render.tileentity.TileEntityModelItemStackRenderer.TEModel;
import mchorse.blockbuster.client.textures.GifTexture;
import mchorse.blockbuster.recording.RecordManager;
import mchorse.blockbuster.recording.RecordPlayer;
import mchorse.blockbuster.recording.RecordRecorder;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.AttackAction;
import mchorse.blockbuster.recording.actions.BreakBlockAction;
import mchorse.blockbuster.recording.actions.ChatAction;
import mchorse.blockbuster.recording.actions.CommandAction;
import mchorse.blockbuster.recording.actions.DropAction;
import mchorse.blockbuster.recording.actions.InteractBlockAction;
import mchorse.blockbuster.recording.actions.InteractEntityAction;
import mchorse.blockbuster.recording.actions.ItemUseAction;
import mchorse.blockbuster.recording.actions.ItemUseBlockAction;
import mchorse.blockbuster.recording.actions.MorphAction;
import mchorse.blockbuster.recording.actions.MorphActionAction;
import mchorse.blockbuster.recording.actions.MountingAction;
import mchorse.blockbuster.recording.actions.PlaceBlockAction;
import mchorse.blockbuster.recording.actions.ShootArrowAction;
import mchorse.blockbuster_pack.morphs.StructureMorph;
import mchorse.metamorph.api.events.MorphActionEvent;
import mchorse.metamorph.api.events.MorphEvent;
import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.math.RayTraceResult.Type;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraftforge.common.util.BlockSnapshot;
import net.minecraftforge.event.CommandEvent;
import net.minecraftforge.event.ServerChatEvent;
import net.minecraftforge.event.entity.EntityMountEvent;
import net.minecraftforge.event.entity.item.ItemTossEvent;
import net.minecraftforge.event.entity.player.ArrowLooseEvent;
import net.minecraftforge.event.entity.player.AttackEntityEvent;
import net.minecraftforge.event.entity.player.FillBucketEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.event.entity.player.PlayerInteractEvent.RightClickBlock;
import net.minecraftforge.event.world.BlockEvent.BreakEvent;
import net.minecraftforge.event.world.BlockEvent.MultiPlaceEvent;
import net.minecraftforge.event.world.BlockEvent.PlaceEvent;
import net.minecraftforge.event.world.WorldEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.Phase;
import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.ServerTickEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.WorldTickEvent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import java.io.IOException;
import java.util.List;
/**
* Event handler for recording purposes.
*
* This event handler listens to different events and then writes them to
* the recording event list (which in turn are being written to the disk
* by RecordThread).
*
* Taken from Mocap mod and rewritten.
*/
public class ActionHandler
{
/**
* Last TE was spotted during block breaking action (used for
* damage control of tile entities)
*/
public static TileEntity lastTE;
/**
* Adds a world event listener
*/
@SubscribeEvent
public void onWorldLoad(WorldEvent.Load event)
{
World world = event.getWorld();
if (!world.isRemote)
{
world.addEventListener(new WorldEventListener(world));
}
if (world instanceof WorldServer && ((WorldServer) world).provider.getDimension() == 0)
{
Blockbuster.reloadServerModels(true);
}
}
@SubscribeEvent
public void onItemUse(PlayerInteractEvent.RightClickItem event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new ItemUseAction(event.getHand()));
}
}
@SubscribeEvent
public void onItemUseBlock(PlayerInteractEvent.RightClickBlock event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
Vec3d hit = event.getHitVec();
BlockPos pos = event.getPos();
if (hit == null)
{
events.add(new ItemUseBlockAction(pos, event.getHand(), event.getFace()));
}
else
{
events.add(new ItemUseBlockAction(pos, event.getHand(), event.getFace(), (float) hit.x - pos.getX(), (float) hit.y - pos.getY(), (float) hit.z - pos.getZ()));
}
}
}
/**
* Event listener for Action.BREAK_BLOCK
*/
@SubscribeEvent
public void onPlayerBreaksBlock(BreakEvent event)
{
EntityPlayer player = event.getPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new BreakBlockAction(event.getPos(), !player.isCreative()));
}
}
/**
* Event listener for Action.INTERACT_BLOCK (when player right clicks on
* a block)
*/
@SubscribeEvent
public void onPlayerRightClickBlock(RightClickBlock event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new InteractBlockAction(event.getPos()));
}
}
/**
* Event listener for entity interact event
*/
@SubscribeEvent
public void onRightClickEntity(PlayerInteractEvent.EntityInteract event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new InteractEntityAction(event.getHand()));
}
}
/**
* Event listener for Action.PLACE_BLOCK
*/
@SubscribeEvent
public void onPlayerPlacesBlock(PlaceEvent event)
{
EntityPlayer player = event.getPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
IBlockState state = event.getPlacedBlock();
Block block = state.getBlock();
this.placeBlock(events, event.getPos(), block, state);
}
}
/**
* Another event listener for Action.PLACE_BLOCK
*/
@SubscribeEvent
public void onPlayerPlacesMultiBlock(MultiPlaceEvent event)
{
EntityPlayer player = event.getPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
List<BlockSnapshot> blocks = event.getReplacedBlockSnapshots();
for (BlockSnapshot snapshot : blocks)
{
IBlockState state = snapshot.getCurrentBlock();
Block block = state.getBlock();
this.placeBlock(events, snapshot.getPos(), block, state);
}
}
}
/**
* Event listener for Action.ATTACK
*/
@SubscribeEvent
public void onPlayerAttack(AttackEntityEvent event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null && !Blockbuster.recordAttackOnSwipe.get())
{
events.add(new AttackAction());
}
}
/**
* Event listener for bucket using. When you place water or lava with
* bucket it doesn't considered place block action like with any other
* types of blocks.
*
* So here's my hack for placing water and lava blocks.
*/
@SubscribeEvent
public void onPlayerUseBucket(FillBucketEvent event)
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
RayTraceResult target = event.getTarget();
if (!player.world.isRemote && events != null && target != null && target.typeOfHit == Type.BLOCK)
{
Item bucket = event.getEmptyBucket().getItem();
BlockPos pos = target.getBlockPos().offset(target.sideHit);
if (bucket == Items.LAVA_BUCKET)
{
this.placeBlock(events, pos, Blocks.FLOWING_LAVA, 0);
}
else if (bucket == Items.WATER_BUCKET)
{
this.placeBlock(events, pos, Blocks.FLOWING_WATER, 0);
}
}
}
private void placeBlock(List<Action> events, BlockPos pos, Block block, IBlockState state)
{
this.placeBlock(events, pos, block, block.getMetaFromState(state));
}
/**
* Place block in given event list
*/
private void placeBlock(List<Action> events, BlockPos pos, Block block, int metadata)
{
ResourceLocation id = block.getRegistryName();
events.add(new PlaceBlockAction(pos, (byte) metadata, id.toString()));
}
/**
* Event listener for Action.MOUNTING (when player mounts other entity)
*/
@SubscribeEvent
public void onPlayerMountsSomething(EntityMountEvent event)
{
if (event.getEntityMounting() instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.getEntityMounting();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new MountingAction(event.getEntityBeingMounted().getUniqueID(), event.isMounting()));
}
}
}
/**
* Event listener for Action.SHOOT_ARROW
*/
@SubscribeEvent
public void onArrowLooseEvent(ArrowLooseEvent event) throws IOException
{
EntityPlayer player = event.getEntityPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new ShootArrowAction(event.getCharge()));
}
}
/**
* Event listener for Action.DROP (when player drops the item from his
* inventory)
*/
@SubscribeEvent
public void onItemTossEvent(ItemTossEvent event) throws IOException
{
EntityPlayer player = event.getPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new DropAction(event.getEntityItem().getItem()));
}
}
/**
* Event listener for Action.CHAT (basically when the player enters
* something in the chat)
*/
@SubscribeEvent
public void onServerChatEvent(ServerChatEvent event)
{
EntityPlayer player = event.getPlayer();
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new ChatAction(event.getMessage()));
}
}
/**
* Event listener for Action.COMMAND (basically when the player enters
* a command in the chat). Adds an action only for server commands.
*/
@SubscribeEvent
public void onPlayerCommand(CommandEvent event)
{
if (!Blockbuster.recordCommands.get())
{
return;
}
ICommandSender sender = event.getSender();
if (sender instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) sender;
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
String command = "/" + event.getCommand().getName();
for (String value : event.getParameters())
{
command += " " + value;
}
events.add(new CommandAction(command));
}
}
}
/**
* Event listener when player logs out. This listener aborts the recording
* for given player (well, if he records, but that {@link RecordManager}'s
* job to find out).
*/
@SubscribeEvent
public void onPlayerLogOut(PlayerLoggedOutEvent event)
{
EntityPlayer player = event.player;
if (!player.world.isRemote)
{
CommonProxy.manager.abort(player);
}
}
/**
* Event listener for MORPH
*
* This is a new event listener for morphing. Before that, there was server
* handler which was responsible for recoring MORPH action.
*/
@SubscribeEvent
public void onPlayerMorph(MorphEvent.Post event)
{
EntityPlayer player = event.player;
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null)
{
events.add(new MorphAction(event.morph));
}
}
/**
* Event listener for MORPH_ACTION
*
* This method will simply submit a {@link MorphActionAction} to the
* event list, if action is valid.
*/
@SubscribeEvent
public void onPlayerMorphAction(MorphActionEvent event)
{
EntityPlayer player = event.player;
List<Action> events = CommonProxy.manager.getActions(player);
if (!player.world.isRemote && events != null && event.isValid())
{
events.add(new MorphActionAction());
}
}
/**
* Event listener for server tick event.
*
* This is probably not the optimal solution, but I'm not really sure how
* to schedule things in Minecraft other way than timers and ticks.
*
* This method is responsible for scheduling record unloading and counting
* down recording process.
*/
@SubscribeEvent
public void onServerTick(ServerTickEvent event)
{
if (event.phase == Phase.START)
{
return;
}
CommonProxy.manager.tick();
CommonProxy.scenes.tick();
}
/**
* Event listener for world tick event.
*
* This stuff will be called between networking and world tick.
* I think it's a good time to spawn actors and execute unsafe actions.
*
* Because if actions to modify the world are performed while the actor
* is updating, they will be displayed to the client with a delay of
* 1 tick.
*/
@SubscribeEvent
public void onWorldServerTick(WorldTickEvent event)
{
if (event.phase == Phase.END || event.world.isRemote)
{
return;
}
CommonProxy.scenes.worldTick(event.world);
}
/**
* This is going to record the player actions
*/
@SubscribeEvent
public void onPlayerTick(PlayerTickEvent event)
{
if (event.phase == Phase.START)
{
return;
}
EntityPlayer player = event.player;
boolean server = !player.world.isRemote;
if (server && CommonProxy.manager.recorders.containsKey(player))
{
RecordRecorder recorder = CommonProxy.manager.recorders.get(player);
if (player.isDead)
{
CommonProxy.manager.halt(player, true, true);
RecordUtils.broadcastInfo("recording.dead", recorder.record.filename);
}
else
{
recorder.record(player);
}
}
IRecording recording = Recording.get(player);
RecordPlayer record = recording.getRecordPlayer();
if (record != null)
{
record.next();
if (record.isFinished() && server)
{
record.stopPlaying();
}
}
}
} | 17,420 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
DamageControlManager.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/capturing/DamageControlManager.java | package mchorse.blockbuster.recording.capturing;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import java.util.HashMap;
import java.util.Map;
/**
* Damage control manager
*
* This person is responsible for managing damage control
*/
public class DamageControlManager
{
/**
* Damage control objects
*/
public Map<Object, DamageControl> damage = new HashMap<Object, DamageControl>();
public void reset()
{
this.damage.clear();
}
/**
* Start observing damage made to terrain
*/
public void addDamageControl(Object object, EntityLivingBase player)
{
if (Blockbuster.damageControl.get())
{
int dist = Blockbuster.damageControlDistance.get();
this.damage.put(object, new DamageControl(player, dist));
}
}
/**
* Restore made damage
*/
public void restoreDamageControl(Object object, World world)
{
DamageControl control = this.damage.remove(object);
if (control != null)
{
control.apply(world);
}
}
/**
* Add an entity to track
*/
public void addEntity(Entity entity)
{
for (DamageControl damage : this.damage.values())
{
damage.entities.add(entity);
}
}
/**
* Add a block to track
*/
public void addBlock(BlockPos pos, IBlockState oldState, World worldIn)
{
for (DamageControl damage : CommonProxy.damage.damage.values())
{
damage.addBlock(new BlockPos(pos), oldState, worldIn);
}
}
} | 1,836 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CloseContainerAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/CloseContainerAction.java | package mchorse.blockbuster.recording.actions;
import mchorse.blockbuster.common.entity.EntityActor;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
public class CloseContainerAction extends Action
{
@Override
public void apply(EntityLivingBase actor)
{
EntityPlayer player = actor instanceof EntityActor ? ((EntityActor) actor).fakePlayer : (EntityPlayer) actor;
if (!player.world.isRemote && player.openContainer != player.inventoryContainer)
{
player.closeScreen();
}
}
}
| 585 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ItemUseAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ItemUseAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumHand;
/**
* Item use action
*
* This action is responsible for using the item in actor's hand. This action
* will right click the item, not will use it on the block.
*/
public class ItemUseAction extends Action
{
public EnumHand hand = EnumHand.MAIN_HAND;
public ItemUseAction()
{}
public ItemUseAction(EnumHand hand)
{
this.hand = hand;
}
@Override
public void apply(EntityLivingBase actor)
{
ItemStack item = actor.getHeldItem(this.hand);
if (item != null)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
EntityPlayer player = actor instanceof EntityActor ? ((EntityActor) actor).fakePlayer : (EntityPlayer) actor;
if (frame == null) return;
player.width = actor.width;
player.height = actor.height;
player.eyeHeight = actor.getEyeHeight();
player.setEntityBoundingBox(actor.getEntityBoundingBox());
player.posX = actor.posX;
player.posY = actor.posY;
player.posZ = actor.posZ;
player.rotationYaw = frame.yaw;
player.rotationPitch = frame.pitch;
player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, actor.getHeldItemMainhand());
player.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, actor.getHeldItemOffhand());
item.getItem().onItemRightClick(actor.world, player, this.hand);
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.hand = buf.readByte() == 0 ? EnumHand.MAIN_HAND : EnumHand.OFF_HAND;
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeByte((byte) (this.hand.equals(EnumHand.MAIN_HAND) ? 0 : 1));
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.hand = tag.getByte("Hand") == 0 ? EnumHand.MAIN_HAND : EnumHand.OFF_HAND;
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setByte("Hand", (byte) (this.hand.equals(EnumHand.MAIN_HAND) ? 0 : 1));
}
} | 2,619 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ShootGunAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ShootGunAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.common.GunProps;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.network.server.gun.ServerHandlerGunInteract;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.blockbuster.utils.NBTUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.ByteBufUtils;
/**
* \* User: Evanechecssss
* \* https://evanechecssss.github.io
* \
*/
public class ShootGunAction extends Action
{
private ItemStack stack;
public ShootGunAction()
{
this(ItemStack.EMPTY);
}
public ShootGunAction(ItemStack stack)
{
this.stack = stack;
}
@Override
public void apply(EntityLivingBase actor)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
EntityPlayer player = actor instanceof EntityPlayer ? (EntityPlayer) actor : ((EntityActor) actor).fakePlayer;
if (frame == null)
{
return;
}
if (player != null)
{
GunProps props = NBTUtils.getGunProps(this.stack);
if (props != null)
{
player.width = actor.width;
player.height = actor.height;
player.eyeHeight = actor.getEyeHeight();
player.setEntityBoundingBox(actor.getEntityBoundingBox());
player.posX = actor.posX;
player.posY = actor.posY;
player.posZ = actor.posZ;
player.rotationYaw = frame.yaw;
player.rotationPitch = frame.pitch;
player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, actor.getHeldItemMainhand());
player.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, actor.getHeldItemOffhand());
ServerHandlerGunInteract.interactWithGun(null, actor, this.stack);
}
else
{
Blockbuster.LOGGER.error("Null gun props");
}
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.stack = ByteBufUtils.readItemStack(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
ByteBufUtils.writeItemStack(buf, this.stack);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.stack = new ItemStack(tag.getCompoundTag("Stack"));
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setTag("Stack", this.stack.serializeNBT());
}
} | 2,921 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ShootArrowAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ShootArrowAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.projectile.EntityTippedArrow;
import net.minecraft.item.ItemBow;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
/**
* Shoot arrow action
*
* This action shoots emulates arrow shooting. This would look confusing when
* the actor lack of bow, he would be like freaking arrow mage or something.
*/
public class ShootArrowAction extends Action
{
public int charge;
public ShootArrowAction()
{}
public ShootArrowAction(int charge)
{
this.charge = charge;
}
/**
* Some code in this method is borrowed from ItemBow, I guess, I don't
* remember
*/
@Override
public void apply(EntityLivingBase actor)
{
World world = actor.world;
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
if (frame == null) return;
EntityTippedArrow arrow = new EntityTippedArrow(world, actor);
float f = ItemBow.getArrowVelocity(this.charge);
arrow.shoot(actor, frame.pitch, frame.yaw, 0.0F, f * 3.0F, 1.0F);
world.spawnEntity(arrow);
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.charge = buf.readByte();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeByte(this.charge);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.charge = tag.getByte("Charge");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setByte("Charge", (byte) this.charge);
}
} | 1,825 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/CommandAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import net.minecraft.command.CommandHandler;
import net.minecraft.command.CommandResultStats.Type;
import net.minecraft.command.ICommandManager;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentString;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.ByteBufUtils;
/**
* Command action
*
* This class is responsible for executing commands.
*/
public class CommandAction extends Action
{
/**
* Command to be executed
*/
public String command = "";
public CommandAction()
{}
public CommandAction(String command)
{
this.command = command;
}
@Override
public void apply(EntityLivingBase actor)
{
if (!this.command.isEmpty())
{
MinecraftServer server = actor.world.getMinecraftServer();
if (server != null)
{
ICommandManager manager = server.commandManager;
manager.executeCommand(new CommandSender(actor), this.command);
}
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.command = ByteBufUtils.readUTF8String(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
ByteBufUtils.writeUTF8String(buf, this.command);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.command = tag.getString("Command");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setString("Command", this.command);
}
/**
* Command action's command sender
*
* This dude is responsible for providing {@link ICommandSender} for the
* {@link CommandHandler}.
*/
public static class CommandSender implements ICommandSender
{
public EntityLivingBase actor;
public CommandSender(EntityLivingBase actor)
{
this.actor = actor;
}
@Override
public String getName()
{
return "CommandAction";
}
@Override
public ITextComponent getDisplayName()
{
return new TextComponentString("CommandAction");
}
@Override
public void sendMessage(ITextComponent component)
{}
@Override
public boolean canUseCommand(int permLevel, String commandName)
{
return true;
}
@Override
public BlockPos getPosition()
{
return new BlockPos(this.actor);
}
@Override
public Vec3d getPositionVector()
{
return new Vec3d(this.actor.posX, this.actor.posY, this.actor.posZ);
}
@Override
public World getEntityWorld()
{
return this.actor.world;
}
@Override
public Entity getCommandSenderEntity()
{
return this.actor;
}
@Override
public boolean sendCommandFeedback()
{
return false;
}
@Override
public void setCommandStat(Type type, int amount)
{}
@Override
public MinecraftServer getServer()
{
return this.actor.world.getMinecraftServer();
}
}
} | 3,697 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ChatAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ChatAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.mclib.utils.TextUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.ByteBufUtils;
/**
* Chat action
*
* Sends chat message with some formatting.
* See {@link ChatAction#apply(EntityLivingBase)} for more information.
*/
public class ChatAction extends Action
{
public String message = "";
public ChatAction()
{}
public ChatAction(String message)
{
this.message = message;
}
public String getMessage(EntityLivingBase actor)
{
String message = this.message;
String prefix = Blockbuster.recordChatPrefix.get();
if (!prefix.isEmpty())
{
message = prefix.replace("%NAME%", actor == null ? "Player" : actor.getName()) + message;
}
return TextUtils.processColoredText(message);
}
@Override
public void apply(EntityLivingBase actor)
{
RecordUtils.broadcastMessage(this.getMessage(actor));
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.message = ByteBufUtils.readUTF8String(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
ByteBufUtils.writeUTF8String(buf, this.message);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.message = tag.getString("Message");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setString("Message", this.message);
}
} | 1,726 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
PlaceBlockAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/PlaceBlockAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import net.minecraft.block.Block;
import net.minecraft.block.SoundType;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.SoundCategory;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.ByteBufUtils;
/**
* Guess what this action does
*
* Does exactly what you think, no less, no more.
*/
public class PlaceBlockAction extends InteractBlockAction
{
public byte metadata;
public String block = "";
public PlaceBlockAction()
{}
public PlaceBlockAction(BlockPos pos, byte metadata, String block)
{
super(pos);
this.metadata = metadata;
this.block = block;
}
@SuppressWarnings("deprecation")
@Override
public void apply(EntityLivingBase actor)
{
Block block = Block.REGISTRY.getObject(new ResourceLocation(this.block));
if (block != null)
{
IBlockState state = actor.world.getBlockState(this.pos);
if (InteractBlockAction.BLACKLIST.contains(state.getBlock().getRegistryName()))
{
return;
}
state = block.getStateFromMeta(this.metadata);
actor.world.setBlockState(this.pos, state);
World world = actor.world;
SoundType soundtype = world.getBlockState(pos).getBlock().getSoundType(world.getBlockState(pos), world, pos, null);
world.playSound(null, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.metadata = buf.readByte();
this.block = ByteBufUtils.readUTF8String(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeByte(this.metadata);
ByteBufUtils.writeUTF8String(buf, this.block);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
super.fromNBT(tag);
this.metadata = tag.getByte("Meta");
this.block = tag.getString("Block");
}
@Override
public void toNBT(NBTTagCompound tag)
{
super.toNBT(tag);
tag.setByte("Meta", this.metadata);
tag.setString("Block", this.block);
}
} | 2,554 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BreakBlockAnimation.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/BreakBlockAnimation.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.capturing.WorldEventListener;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.math.BlockPos;
/**
* Breaking block animation
*
* This action is responsible for animating blocks which are about to be
* broken. This action is recorded in the {@link WorldEventListener}.
*/
public class BreakBlockAnimation extends InteractBlockAction
{
public int progress;
public BreakBlockAnimation()
{}
public BreakBlockAnimation(BlockPos pos, int progress)
{
super(pos);
this.progress = progress;
}
@Override
public void apply(EntityLivingBase actor)
{
actor.world.sendBlockBreakProgress(-1, this.pos, this.progress);
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.progress = buf.readInt();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeInt(this.progress);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
super.fromNBT(tag);
this.progress = tag.getInteger("Progress");
}
@Override
public void toNBT(NBTTagCompound tag)
{
super.toNBT(tag);
tag.setInteger("Progress", this.progress);
}
} | 1,415 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BreakBlockAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/BreakBlockAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.math.BlockPos;
/**
* Breaking block action
*
* Actor breaks the block
*/
public class BreakBlockAction extends InteractBlockAction
{
public boolean drop = false;
public BreakBlockAction()
{}
public BreakBlockAction(BlockPos pos, boolean drop)
{
super(pos);
this.drop = drop;
}
@Override
public void apply(EntityLivingBase actor)
{
actor.world.destroyBlock(this.pos, this.drop);
actor.world.sendBlockBreakProgress(actor.getEntityId(), this.pos, -1);
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.drop = buf.readBoolean();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeBoolean(this.drop);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
super.fromNBT(tag);
this.drop = tag.getBoolean("Drop");
}
@Override
public void toNBT(NBTTagCompound tag)
{
super.toNBT(tag);
tag.setBoolean("Drop", this.drop);
}
}
| 1,265 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
DropAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/DropAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.mclib.utils.NBTUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.math.MathHelper;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import java.util.Random;
/**
* Item drop action
*
* Actor tosses held item away just like player when pressing "q" key
*/
public class DropAction extends Action
{
public NBTTagCompound itemData;
public DropAction()
{
this.itemData = new NBTTagCompound();
}
public DropAction(ItemStack item)
{
this();
item.writeToNBT(this.itemData);
}
@Override
public void apply(EntityLivingBase actor)
{
if (this.itemData == null)
{
return;
}
final float PI = 3.1415927F;
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
ItemStack items = new ItemStack(this.itemData);
if (items == null || frame == null)
{
return;
}
EntityItem item = new EntityItem(actor.world, actor.posX, actor.posY - 0.3D + actor.getEyeHeight(), actor.posZ, items);
Random rand = new Random();
float f = 0.3F;
float yaw = frame.yaw;
float pitch = frame.pitch;
item.motionX = (-MathHelper.sin(yaw / 180.0F * PI) * MathHelper.cos(pitch / 180.0F * PI) * f);
item.motionZ = (MathHelper.cos(yaw / 180.0F * PI) * MathHelper.cos(pitch / 180.0F * PI) * f);
item.motionY = (-MathHelper.sin(pitch / 180.0F * PI) * f + 0.1F);
item.setPickupDelay(40);
f = 0.02F;
float f1 = rand.nextFloat() * PI * 2.0F * rand.nextFloat();
item.motionX += Math.cos(f1) * f;
item.motionY += (rand.nextFloat() - rand.nextFloat()) * 0.1F;
item.motionZ += Math.sin(f1) * f;
actor.world.spawnEntity(item);
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.itemData = NBTUtils.readInfiniteTag(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
ByteBufUtils.writeTag(buf, this.itemData);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.itemData = tag.getCompoundTag("Data");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setTag("Data", this.itemData);
}
} | 2,657 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
InteractEntityAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/InteractEntityAction.java | package mchorse.blockbuster.recording.actions;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.mclib.utils.RayTracing;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.EnumHand;
public class InteractEntityAction extends ItemUseAction
{
public InteractEntityAction()
{}
public InteractEntityAction(EnumHand hand)
{
super(hand);
}
@Override
public void apply(EntityLivingBase actor)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
EntityPlayer player = actor instanceof EntityPlayer ? (EntityPlayer) actor : ((EntityActor) actor).fakePlayer;
if (frame == null) return;
float yaw = actor.rotationYaw;
float pitch = actor.rotationPitch;
float yawHead = actor.rotationYawHead;
actor.rotationYaw = frame.yaw;
actor.rotationPitch = frame.pitch;
actor.rotationYawHead = frame.yawHead;
Entity target = RayTracing.getTargetEntity(actor, 5.0);
actor.rotationYaw = yaw;
actor.rotationPitch = pitch;
actor.rotationYawHead = yawHead;
if (player != actor)
{
this.copyActor(actor, player, frame);
}
if (target != null)
{
player.interactOn(target, this.hand);
}
}
} | 1,525 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
MorphAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/MorphAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.metamorph.api.MorphAPI;
import mchorse.metamorph.api.MorphManager;
import mchorse.metamorph.api.MorphUtils;
import mchorse.metamorph.api.morphs.AbstractMorph;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
/**
* Morph action
*
* This action is responsible for changing the model and skin of actor during
* the playback. This action is submitted when player morphs with Metamorph's
* API.
*/
public class MorphAction extends Action
{
public AbstractMorph morph;
private boolean force;
public MorphAction()
{}
public MorphAction(AbstractMorph morph)
{
this.morph = morph;
}
@Override
public void apply(EntityLivingBase actor)
{
AbstractMorph morph = MorphUtils.copy(this.morph);
if (actor instanceof EntityPlayer)
{
MorphAPI.morph((EntityPlayer) actor, morph, true);
}
else if (actor instanceof EntityActor)
{
EntityActor act = (EntityActor) actor;
act.morph(morph, false);
if (!act.world.isRemote)
{
act.notifyPlayers();
}
}
}
@Override
public void applyWithForce(EntityLivingBase actor)
{
AbstractMorph morph = MorphUtils.copy(this.morph);
if (actor instanceof EntityPlayer)
{
MorphAPI.morph((EntityPlayer) actor, morph, true);
}
else if (actor instanceof EntityActor)
{
EntityActor act = (EntityActor) actor;
act.morph(morph, true);
if (!act.world.isRemote)
{
act.notifyPlayers();
}
}
}
public void applyWithOffset(EntityLivingBase actor, int offset, AbstractMorph previous, int previousOffset, boolean resume)
{
AbstractMorph morph = MorphUtils.copy(this.morph);
/* Sorry, fake players can't be synced */
if (actor instanceof EntityPlayer)
{
MorphAPI.morph((EntityPlayer) actor, morph, true);
}
else if (actor instanceof EntityActor)
{
EntityActor act = (EntityActor) actor;
if (act.world.isRemote)
{
act.applyPause(MorphUtils.copy(morph), offset, MorphUtils.copy(previous), previousOffset, resume);
}
else
{
act.morphPause(morph, offset, previous, previousOffset, resume);
act.notifyPlayers();
}
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.morph = MorphUtils.morphFromBuf(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
MorphUtils.morphToBuf(buf, this.morph);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.morph = MorphManager.INSTANCE.morphFromNBT(tag.getCompoundTag("Morph"));
}
@Override
public void toNBT(NBTTagCompound tag)
{
if (this.morph != null)
{
tag.setTag("Morph", this.morph.toNBT());
}
}
@Override
public boolean isSafe()
{
return true;
}
} | 3,427 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
DamageAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/DamageAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.DamageSource;
/**
* Damage action
*
* This action is responsible for dealing damage to the actor. Currently used
* for killing the actor.
*/
public class DamageAction extends Action
{
public float damage;
public DamageAction()
{}
public DamageAction(float damage)
{
this.damage = damage;
}
@Override
public void apply(EntityLivingBase actor)
{
actor.attackEntityFrom(DamageSource.OUT_OF_WORLD, this.damage);
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.damage = buf.readFloat();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeFloat(this.damage);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.damage = tag.getFloat("Damage");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setFloat("Damage", this.damage);
}
} | 1,156 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
EquipAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/EquipAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.mclib.utils.NBTUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.ByteBufUtils;
/**
* Equip item action
*
* This action equips an item from replay to the actor, so he either equips the
* item into one of the hands or in of the armor slots (shoes, leggins, chestplate,
* or helmet)
*
* This action is also called to "de-equip" an item from equipment
*/
public class EquipAction extends Action
{
public byte armorSlot;
public NBTTagCompound itemData;
private byte hotbarSlot = -1;
public EquipAction()
{
this.itemData = new NBTTagCompound();
}
public EquipAction(byte armorSlot, ItemStack item)
{
this();
this.armorSlot = armorSlot;
if (item != null)
{
item.writeToNBT(this.itemData);
}
}
public EquipAction(byte armorSlot, byte hotbarSlot, ItemStack item)
{
this(armorSlot, item);
this.hotbarSlot = hotbarSlot;
}
@Override
public void apply(EntityLivingBase actor)
{
EntityEquipmentSlot slot = this.getSlotByIndex(this.armorSlot);
if (slot == null)
{
return;
}
if (this.itemData == null)
{
this.updateCurrentItemIndex(actor, slot);
actor.setItemStackToSlot(slot, ItemStack.EMPTY);
}
else
{
this.updateCurrentItemIndex(actor, slot);
actor.setItemStackToSlot(slot, new ItemStack(this.itemData));
}
}
/**
* The currentItem index in the inventory can be delayed (client shows different current slot than what is on server).
* The method {@link EntityLivingBase#setItemStackToSlot(EntityEquipmentSlot, ItemStack)}
* sets the currentItem index to the provided itemStack for MAINHAND, this can screw up the inventory.
*/
private void updateCurrentItemIndex(EntityLivingBase entity, EntityEquipmentSlot slot)
{
if (entity instanceof EntityPlayer && this.hotbarSlot != -1 && slot == EntityEquipmentSlot.MAINHAND)
{
((EntityPlayer) entity).inventory.currentItem = this.hotbarSlot;
}
}
private EntityEquipmentSlot getSlotByIndex(int index)
{
for (EntityEquipmentSlot slot : EntityEquipmentSlot.values())
{
if (slot.getSlotIndex() == index) return slot;
}
return null;
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.armorSlot = buf.readByte();
this.hotbarSlot = buf.readByte();
this.itemData = NBTUtils.readInfiniteTag(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeByte(this.armorSlot);
buf.writeByte(this.hotbarSlot);
ByteBufUtils.writeTag(buf, this.itemData);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.armorSlot = tag.getByte("Slot");
this.hotbarSlot = tag.hasKey("HotbarSlot") ? tag.getByte("HotbarSlot") : this.hotbarSlot;
if (tag.hasKey("Data"))
{
this.itemData = tag.getCompoundTag("Data");
}
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setByte("Slot", this.armorSlot);
if (this.hotbarSlot != -1)
{
tag.setByte("HotbarSlot", this.hotbarSlot);
}
if (this.itemData != null)
{
tag.setTag("Data", this.itemData);
}
}
@Override
public boolean isSafe()
{
return true;
}
} | 3,888 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SwipeAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/SwipeAction.java | package mchorse.blockbuster.recording.actions;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.recording.RecordPlayer;
import mchorse.blockbuster.utils.EntityUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.init.SoundEvents;
import net.minecraft.network.play.server.SPacketAnimation;
import net.minecraft.util.EnumHand;
/**
* Swipe action
*
* Swipes actor's hand.
*/
public class SwipeAction extends Action
{
public SwipeAction()
{}
@Override
public void apply(EntityLivingBase actor)
{
RecordPlayer player = EntityUtils.getRecordPlayer(actor);
actor.swingArm(EnumHand.MAIN_HAND);
/* Hack to swing the arm for the real player */
if (player != null && player.realPlayer)
{
((EntityPlayerMP) player.actor).connection.sendPacket(new SPacketAnimation(player.actor, 0));
}
if (Blockbuster.actorSwishSwipe.get())
{
actor.world.playSound(null, actor.posX, actor.posY, actor.posZ, SoundEvents.ENTITY_PLAYER_ATTACK_WEAK, actor.getSoundCategory(), 1.0F, 1.0F);
}
}
@Override
public boolean isSafe()
{
return true;
}
} | 1,257 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
MountingAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/MountingAction.java | package mchorse.blockbuster.recording.actions;
import java.util.UUID;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.mclib.utils.RayTracing;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
/**
* Mounting action
*
* This actor makes actor to mount or unmount an entity by UUID.
* I should probably move from UUID to using a type of entity with given
* radius (3-5 blocks).
*/
public class MountingAction extends Action
{
/**
* Default UUID
*/
public static final UUID DEFAULT = new UUID(0, 0);
public UUID target = DEFAULT;
public boolean isMounting;
public MountingAction()
{}
public MountingAction(UUID target, boolean isMounting)
{
this.target = target;
this.isMounting = isMounting;
}
@Override
public void apply(EntityLivingBase actor)
{
Entity mount = EntityUtils.entityByUUID(actor.world, this.target);
if (mount == null)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
if (frame == null) return;
float yaw = actor.rotationYaw;
float pitch = actor.rotationPitch;
float yawHead = actor.rotationYawHead;
actor.rotationYaw = frame.yaw;
actor.rotationPitch = frame.pitch;
actor.rotationYawHead = frame.yawHead;
mount = RayTracing.getTargetEntity(actor, 5.0);
actor.rotationYaw = yaw;
actor.rotationPitch = pitch;
actor.rotationYawHead = yawHead;
}
if (mount == null && this.isMounting)
{
return;
}
if (this.isMounting)
{
actor.startRiding(mount);
}
else
{
actor.dismountRidingEntity();
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.target = new UUID(buf.readLong(), buf.readLong());
this.isMounting = buf.readBoolean();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeLong(this.target.getMostSignificantBits());
buf.writeLong(this.target.getLeastSignificantBits());
buf.writeBoolean(this.isMounting);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.target = new UUID(tag.getLong("Most"), tag.getLong("Least"));
this.isMounting = tag.getBoolean("Mounting");
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setLong("Most", this.target.getMostSignificantBits());
tag.setLong("Least", this.target.getLeastSignificantBits());
tag.setBoolean("Mounting", this.isMounting);
}
} | 2,882 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
MorphActionAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/MorphActionAction.java | package mchorse.blockbuster.recording.actions;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.metamorph.api.morphs.AbstractMorph;
import net.minecraft.entity.EntityLivingBase;
/**
* Morph's action action
*
* This method is responsible for executing morph's action, if it has one.
*/
public class MorphActionAction extends Action
{
public MorphActionAction()
{}
@Override
public void apply(EntityLivingBase actor)
{
AbstractMorph morph = mchorse.metamorph.api.EntityUtils.getMorph(actor);
if (morph != null)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
if (frame == null) return;
float yaw = actor.rotationYaw;
float yawHead = actor.rotationYaw;
float pitch = actor.rotationPitch;
float prevYaw = actor.prevRotationYaw;
float prevYawHead = actor.prevRotationYawHead;
float prevPitch = actor.prevRotationPitch;
actor.rotationYaw = actor.prevRotationYaw = frame.yaw;
actor.rotationYawHead = actor.prevRotationYawHead = frame.yawHead;
actor.rotationPitch = actor.prevRotationPitch = frame.pitch;
morph.action(actor);
actor.rotationYaw = yaw;
actor.rotationYawHead = yawHead;
actor.rotationPitch = pitch;
actor.prevRotationYaw = prevYaw;
actor.prevRotationYawHead = prevYawHead;
actor.prevRotationPitch = prevPitch;
}
}
} | 1,591 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ItemUseBlockAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ItemUseBlockAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumHand;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
public class ItemUseBlockAction extends ItemUseAction
{
public BlockPos pos = BlockPos.ORIGIN;
public EnumFacing facing = EnumFacing.UP;
public float hitX;
public float hitY;
public float hitZ;
public ItemUseBlockAction()
{}
public ItemUseBlockAction(BlockPos pos, EnumHand hand, EnumFacing facing)
{
super(hand);
this.pos = pos;
this.facing = facing;
}
public ItemUseBlockAction(BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ)
{
this(pos, hand, facing);
this.hitX = hitX;
this.hitY = hitY;
this.hitZ = hitZ;
}
@Override
public void apply(EntityLivingBase actor)
{
ItemStack item = actor.getHeldItem(this.hand);
if (item != null)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
EntityPlayer player = actor instanceof EntityActor ? ((EntityActor) actor).fakePlayer : (EntityPlayer) actor;
if (frame == null) return;
player.width = actor.width;
player.height = actor.height;
player.eyeHeight = actor.getEyeHeight();
player.setEntityBoundingBox(actor.getEntityBoundingBox());
player.posX = actor.posX;
player.posY = actor.posY;
player.posZ = actor.posZ;
player.rotationYaw = frame.yaw;
player.rotationPitch = frame.pitch;
player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, actor.getHeldItemMainhand());
player.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, actor.getHeldItemOffhand());
ItemStack stack = actor.getHeldItem(this.hand);
int meta = stack.getMetadata();
int size = stack.getCount();
item.getItem().onItemUse(player, actor.world, this.pos, this.hand, this.facing, this.hitX, this.hitY, this.hitZ);
stack.setItemDamage(meta);
stack.setCount(size);
}
}
@Override
public void changeOrigin(double rotation, double newX, double newY, double newZ, double firstX, double firstY, double firstZ)
{
/* I don't like wasting variables */
firstX = this.pos.getX() - firstX;
firstX = this.pos.getY() - firstY;
firstX = this.pos.getZ() - firstZ;
if (rotation != 0)
{
Vec3d vec = new Vec3d(this.hitX, this.hitY, this.hitZ);
vec = vec.rotateYaw((float) (rotation / 180 * Math.PI));
this.hitX = (float) vec.x;
this.hitY = (float) vec.y;
this.hitZ = (float) vec.z;
float cos = (float) Math.cos(rotation / 180 * Math.PI);
float sin = (float) Math.sin(rotation / 180 * Math.PI);
double xx = firstX * cos - firstZ * sin;
double zz = firstX * sin + firstZ * cos;
firstX = xx;
firstZ = zz;
}
newX += firstX;
newY += firstY;
newZ += firstZ;
this.pos = new BlockPos(newX, newY, newZ);
}
@Override
public void flip(String axis, double coordinate)
{
if (axis.equals("x"))
{
double diff = coordinate - this.pos.getX();
this.hitX = 1 - this.hitX;
this.pos = new BlockPos(coordinate + diff, this.pos.getY(), this.pos.getZ());
}
else
{
double diff = coordinate - this.pos.getZ();
this.hitZ = 1 - this.hitZ;
this.pos = new BlockPos(this.pos.getX(), this.pos.getY(), coordinate + diff);
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.pos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
this.facing = EnumFacing.values()[buf.readByte()];
this.hitX = buf.readFloat();
this.hitY = buf.readFloat();
this.hitZ = buf.readFloat();
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeInt(this.pos.getX());
buf.writeInt(this.pos.getY());
buf.writeInt(this.pos.getZ());
buf.writeByte((byte) this.facing.ordinal());
buf.writeFloat(this.hitX);
buf.writeFloat(this.hitY);
buf.writeFloat(this.hitZ);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
super.fromNBT(tag);
this.pos = new BlockPos(tag.getInteger("PosX"), tag.getInteger("PosY"), tag.getInteger("PosZ"));
this.facing = EnumFacing.values()[tag.getByte("Facing")];
this.hitX = tag.getFloat("HitX");
this.hitY = tag.getFloat("HitY");
this.hitZ = tag.getFloat("HitZ");
}
@Override
public void toNBT(NBTTagCompound tag)
{
super.toNBT(tag);
tag.setInteger("PosX", this.pos.getX());
tag.setInteger("PosY", this.pos.getY());
tag.setInteger("PosZ", this.pos.getZ());
tag.setByte("Facing", (byte) this.facing.ordinal());
tag.setFloat("HitX", this.hitX);
tag.setFloat("HitY", this.hitX);
tag.setFloat("HitZ", this.hitX);
}
} | 5,757 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
InteractBlockAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/InteractBlockAction.java | package mchorse.blockbuster.recording.actions;
import com.google.common.collect.ImmutableSet;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.common.block.BlockDirector;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.LTHelper;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumHand;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import java.util.Set;
/**
* Interact block action
*
* Makes actor interact with a block (press button, switch lever, open the door,
* etc.)
*
* If there was CL4P-TP actor in this mod, this action would be called
* IntergradeBlockAction :D
*/
public class InteractBlockAction extends Action
{
public static final Set<ResourceLocation> BLACKLIST = ImmutableSet.of(
new ResourceLocation("littletiles:blocklittletiles")
);
public BlockPos pos = BlockPos.ORIGIN;
public InteractBlockAction()
{}
public InteractBlockAction(BlockPos pos)
{
this.pos = pos;
}
@Override
public void apply(EntityLivingBase actor)
{
IBlockState state = actor.world.getBlockState(this.pos);
/* Black listed block */
if (state.getBlock() instanceof BlockDirector)
{
return;
}
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
EntityPlayer player = actor instanceof EntityActor ? ((EntityActor) actor).fakePlayer : (EntityPlayer) actor;
if (frame == null) return;
if (player != actor)
{
this.copyActor(actor, player, frame);
}
if (!LTHelper.playerRightClickServer(player, frame))
{
if (BLACKLIST.contains(state.getBlock().getRegistryName()))
{
return;
}
state.getBlock().onBlockActivated(actor.world, this.pos, state, player, EnumHand.MAIN_HAND, null, this.pos.getX(), this.pos.getY(), this.pos.getZ());
}
}
@Override
public void changeOrigin(double rotation, double newX, double newY, double newZ, double firstX, double firstY, double firstZ)
{
/* I don't like wasting variables */
firstX = this.pos.getX() - firstX;
firstY = this.pos.getY() - firstY;
firstZ = this.pos.getZ() - firstZ;
if (rotation != 0)
{
float cos = (float) Math.cos(rotation / 180 * Math.PI);
float sin = (float) Math.sin(rotation / 180 * Math.PI);
double xx = firstX * cos - firstZ * sin;
double zz = firstX * sin + firstZ * cos;
firstX = xx;
firstZ = zz;
}
newX += firstX;
newY += firstY;
newZ += firstZ;
this.pos = new BlockPos(newX, newY, newZ);
}
@Override
public void flip(String axis, double coordinate)
{
if (axis.equals("x"))
{
double diff = coordinate - this.pos.getX();
this.pos = new BlockPos(coordinate + diff, this.pos.getY(), this.pos.getZ());
}
else
{
double diff = coordinate - this.pos.getZ();
this.pos = new BlockPos(this.pos.getX(), this.pos.getY(), coordinate + diff);
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.pos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeInt(this.pos.getX());
buf.writeInt(this.pos.getY());
buf.writeInt(this.pos.getZ());
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.pos = new BlockPos(tag.getInteger("X"), tag.getInteger("Y"), tag.getInteger("Z"));
}
@Override
public void toNBT(NBTTagCompound tag)
{
tag.setInteger("X", this.pos.getX());
tag.setInteger("Y", this.pos.getY());
tag.setInteger("Z", this.pos.getZ());
}
} | 4,355 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
AttackAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/AttackAction.java | package mchorse.blockbuster.recording.actions;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.utils.EntityUtils;
import mchorse.mclib.utils.RayTracing;
import mchorse.metamorph.api.morphs.AbstractMorph;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.DamageSource;
/**
* Attack action
*
* This action is responsible for attacking an entity in in front of the actor.
*/
public class AttackAction extends DamageAction
{
public AttackAction()
{
this.damage = 2F;
}
public AttackAction(float damage)
{
super(damage);
}
@Override
public void apply(EntityLivingBase actor)
{
Frame frame = EntityUtils.getRecordPlayer(actor).getCurrentFrame();
if (frame == null) return;
float yaw = actor.rotationYaw;
float pitch = actor.rotationPitch;
float yawHead = actor.rotationYawHead;
actor.rotationYaw = frame.yaw;
actor.rotationPitch = frame.pitch;
actor.rotationYawHead = frame.yawHead;
Entity target = RayTracing.getTargetEntity(actor, 5.0);
actor.rotationYaw = yaw;
actor.rotationPitch = pitch;
actor.rotationYawHead = yawHead;
if (target != null)
{
target.attackEntityFrom(DamageSource.causeMobDamage(actor), this.damage);
AbstractMorph morph = mchorse.metamorph.api.EntityUtils.getMorph(actor);
if (morph != null)
{
morph.attack(target, actor);
}
}
}
@Override
public void fromNBT(NBTTagCompound tag)
{
if (tag.hasKey("Damage"))
{
this.damage = tag.getFloat("Damage");
}
}
} | 1,816 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
HotbarChangeAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/HotbarChangeAction.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.mclib.utils.NBTUtils;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.ByteBufUtils;
public class HotbarChangeAction extends Action
{
private int slotToChange = -1;
private NBTTagCompound newItemStack;
public HotbarChangeAction()
{
this.newItemStack = new NBTTagCompound();
}
public HotbarChangeAction(int slotToChange, ItemStack newItemStack)
{
this();
this.slotToChange = slotToChange;
if (newItemStack != null)
{
this.newItemStack = newItemStack.writeToNBT(new NBTTagCompound());
}
}
public int getSlot()
{
return this.slotToChange;
}
public void setSlot(int slot)
{
this.slotToChange = slot;
}
public ItemStack getItemStack()
{
return new ItemStack(this.newItemStack);
}
public void setItemStack(ItemStack itemStack)
{
if (itemStack != null)
{
this.newItemStack = itemStack.writeToNBT(new NBTTagCompound());
}
}
@Override
public void apply(EntityLivingBase entity)
{
if (entity instanceof EntityPlayer && this.slotToChange != -1)
{
EntityPlayer player = (EntityPlayer) entity;
player.inventory.setInventorySlotContents(this.slotToChange, new ItemStack(this.newItemStack));
}
}
@Override
public void fromBuf(ByteBuf buf)
{
super.fromBuf(buf);
this.slotToChange = buf.readInt();
this.newItemStack = NBTUtils.readInfiniteTag(buf);
}
@Override
public void toBuf(ByteBuf buf)
{
super.toBuf(buf);
buf.writeInt(this.slotToChange);
ByteBufUtils.writeTag(buf, this.newItemStack);
}
@Override
public void fromNBT(NBTTagCompound tag)
{
this.slotToChange = tag.hasKey("Slot") ? tag.getInteger("Slot") : this.slotToChange;
if (tag.hasKey("ItemStack"))
{
this.newItemStack = tag.getCompoundTag("ItemStack");
}
}
@Override
public void toNBT(NBTTagCompound tag)
{
if (this.slotToChange != -1)
{
tag.setInteger("Slot", this.slotToChange);
}
if (this.newItemStack != null)
{
tag.setTag("ItemStack", this.newItemStack);
}
}
@Override
public boolean isSafe()
{
return true;
}
}
| 2,660 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
Action.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/Action.java | package mchorse.blockbuster.recording.actions;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.data.Frame;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.nbt.NBTTagCompound;
/**
* Parent of all recording actions
*
* This class holds additional information about player's actions performed during
* recording. Supports abstraction and stuffz.
*/
public abstract class Action
{
/**
* Apply action on an actor (shoot arrow, mount entity, break block, etc.)
*
* Some action doesn't necessarily should have apply method (that's why this
* method is empty)
*/
public void apply(EntityLivingBase actor)
{}
public void applyWithForce(EntityLivingBase actor)
{
this.apply(actor);
}
public void changeOrigin(double rotation, double newX, double newY, double newZ, double firstX, double firstY, double firstZ)
{}
public void flip(String axis, double coordinate)
{}
public void copyActor(EntityLivingBase actor, EntityPlayer player, Frame frame)
{
player.width = actor.width;
player.height = actor.height;
player.eyeHeight = actor.getEyeHeight();
player.setEntityBoundingBox(actor.getEntityBoundingBox());
player.posX = actor.posX;
player.posY = actor.posY;
player.posZ = actor.posZ;
player.rotationYaw = frame.yaw;
player.rotationPitch = frame.pitch;
player.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, actor.getHeldItemMainhand());
player.setItemStackToSlot(EntityEquipmentSlot.OFFHAND, actor.getHeldItemOffhand());
}
/**
* Persist action from byte buffer. Used for sending the action
* over the network.
*/
public void fromBuf(ByteBuf buf)
{}
/**
* Persist action to byte buffer. Used for sending the action over
* the network.
*/
public void toBuf(ByteBuf buf)
{}
/**
* Persist action from NBT tag. Used for loading from the disk.
*/
public void fromNBT(NBTTagCompound tag)
{}
/**
* Persist action to NBT tag. Used for saving to the disk.
*/
public void toNBT(NBTTagCompound tag)
{}
/**
* Whether this action is safe. Safe action means that it doesn't
* modify the world, at max, only its user.
*/
public boolean isSafe()
{
return false;
}
} | 2,510 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
ActionRegistry.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/recording/actions/ActionRegistry.java | package mchorse.blockbuster.recording.actions;
import java.util.HashMap;
import java.util.Map;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import io.netty.buffer.ByteBuf;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.AttackAction;
import mchorse.blockbuster.recording.actions.BreakBlockAction;
import mchorse.blockbuster.recording.actions.BreakBlockAnimation;
import mchorse.blockbuster.recording.actions.ChatAction;
import mchorse.blockbuster.recording.actions.CommandAction;
import mchorse.blockbuster.recording.actions.DamageAction;
import mchorse.blockbuster.recording.actions.DropAction;
import mchorse.blockbuster.recording.actions.EquipAction;
import mchorse.blockbuster.recording.actions.InteractBlockAction;
import mchorse.blockbuster.recording.actions.ItemUseAction;
import mchorse.blockbuster.recording.actions.ItemUseBlockAction;
import mchorse.blockbuster.recording.actions.MorphAction;
import mchorse.blockbuster.recording.actions.MorphActionAction;
import mchorse.blockbuster.recording.actions.MountingAction;
import mchorse.blockbuster.recording.actions.PlaceBlockAction;
import mchorse.blockbuster.recording.actions.ShootArrowAction;
import mchorse.blockbuster.recording.actions.SwipeAction;
public class ActionRegistry
{
/**
* Bi-directional map between class and byte ID
*/
public static final BiMap<Class<? extends Action>, Byte> CLASS_TO_ID = HashBiMap.create();
/**
* Bi-directional map map of action types mapped to corresponding class
*/
public static final BiMap<String, Class<? extends Action>> NAME_TO_CLASS = HashBiMap.create();
/**
* A mapping between string named to byte type of the fixture
*/
public static final Map<String, Byte> NAME_TO_ID = new HashMap<String, Byte>();
/**
* Next available id
*/
private static byte NEXT_ID = 0;
/**
* Create an action from type
*/
public static Action fromType(byte type) throws Exception
{
Class<? extends Action> clazz = CLASS_TO_ID.inverse().get(type);
if (clazz == null)
{
throw new Exception("Action by type '" + type + "' wasn't found!");
}
return clazz.getConstructor().newInstance();
}
/**
* Create an action from type
*/
public static Action fromName(String name) throws Exception
{
Class<? extends Action> clazz = NAME_TO_CLASS.get(name);
if (clazz == null)
{
throw new Exception("Action by type '" + name + "' wasn't found!");
}
return clazz.getConstructor().newInstance();
}
/**
* Get type of the action
*/
public static byte getType(Action action)
{
if (action == null)
{
return -1;
}
Byte type = CLASS_TO_ID.get(action.getClass());
return type == null ? -1 : type;
}
public static int getRegisterdActionCount()
{
return CLASS_TO_ID.size();
}
public static int getMaxID()
{
return NEXT_ID - 1;
}
/**
* Write an action to byte buffer
*/
public static void toByteBuf(Action action, ByteBuf buffer)
{
byte type = getType(action);
buffer.writeByte(type);
if (action != null)
{
action.toBuf(buffer);
}
}
/**
* Create an action out of byte buffer
*/
public static Action fromByteBuf(ByteBuf buffer)
{
byte type = buffer.readByte();
if (type == -1)
{
return null;
}
try
{
Action action = fromType(type);
action.fromBuf(buffer);
return action;
}
catch (Exception e)
{
e.printStackTrace();
}
return null;
}
/**
* Register given camera fixture
*/
public static void register(String name, Class<? extends Action> clazz)
{
register(name, NEXT_ID, clazz);
NEXT_ID++;
}
/**
* Register given camera fixture
*/
private static void register(String name, int id, Class<? extends Action> clazz)
{
if (CLASS_TO_ID.containsKey(clazz))
{
return;
}
CLASS_TO_ID.put(clazz, (byte) id);
NAME_TO_ID.put(name, (byte) id);
NAME_TO_CLASS.put(name, clazz);
}
static
{
/* Register Blockbuster actions */
register("chat", 1, ChatAction.class);
register("swipe", 2, SwipeAction.class);
register("drop", 3, DropAction.class);
register("equip", 4, EquipAction.class);
register("shoot_arrow", 5, ShootArrowAction.class);
register("place_block", 7, PlaceBlockAction.class);
register("mounting", 8, MountingAction.class);
register("interact_block", 9, InteractBlockAction.class);
register("break_block", 10, BreakBlockAction.class);
register("morph", 12, MorphAction.class);
register("attack", 13, AttackAction.class);
register("damage", 14, DamageAction.class);
register("morph_action", 15, MorphActionAction.class);
register("command", 16, CommandAction.class);
register("break_animation", 17, BreakBlockAnimation.class);
register("use_item", 18, ItemUseAction.class);
register("use_item_block", 19, ItemUseBlockAction.class);
register("use_gun", 20, ShootGunAction.class);
register("hotbar_change", 21, HotbarChangeAction.class);
/* Set next ID to max */
NEXT_ID = 22;
register("interact_entity", InteractEntityAction.class);
register("close_container", CloseContainerAction.class);
}
} | 5,793 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BBCoreClassTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/BBCoreClassTransformer.java | package mchorse.blockbuster.core;
import mchorse.blockbuster.core.transformers.*;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LdcInsnNode;
import org.objectweb.asm.tree.LineNumberNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.VarInsnNode;
import java.util.Iterator;
public class BBCoreClassTransformer extends CoreClassTransformer
{
private WorldTransformer world = new WorldTransformer();
private RenderGlobalTransformer render = new RenderGlobalTransformer();
private EntityRendererTransformer entityRenderer = new EntityRendererTransformer();
private RenderPlayerTransformer playerTransformer = new RenderPlayerTransformer();
private RenderItemTransformer renderItem = new RenderItemTransformer();
private RenderEntityItemTransformer renderEntityItemTransformer = new RenderEntityItemTransformer();
private EntityTransformer entity = new EntityTransformer();
private EntityTransformationUtilsTransformer entityTransformationUtils = new EntityTransformationUtilsTransformer();
private EntityItemTransformer entityItemTransformer = new EntityItemTransformer();
private InventoryPlayerTransformer inventoryPlayerTransformer = new InventoryPlayerTransformer();
@Override
public byte[] transform(String name, String transformedName, byte[] basicClass)
{
if (checkName(name, "amu", "net.minecraft.world.World"))
{
System.out.println("BBCoreMod: Transforming World class (" + name + ")");
return this.world.transform(name, basicClass);
}
else if (checkName(name, "cct", "net.minecraft.client.renderer.entity.RenderPlayer")){
System.out.println("BBCoreMod: Transforming RenderPlayer class (" + name + ")");
return this.playerTransformer.transform(name,basicClass);
}
else if (checkName(name, "buy", "net.minecraft.client.renderer.RenderGlobal"))
{
System.out.println("BBCoreMod: Transforming RenderGlobal class (" + name + ")");
return this.render.transform(name, basicClass);
}
else if (checkName(name, "vg", "net.minecraft.entity.Entity"))
{
System.out.println("BBCoreMod: Transforming Entity class (" + name + ")");
return this.entity.transform(name, basicClass);
}
else if (name.equals("mchorse.blockbuster.utils.EntityTransformationUtils"))
{
System.out.println("BBCoreMod: Transforming EntityTransformationUtils class (" + name + ")");
return this.entityTransformationUtils.transform(name, basicClass);
}
else if (checkName(name, "buq", "net.minecraft.client.renderer.EntityRenderer"))
{
System.out.println("BBCoreMod: Transforming EntityRenderer class (" + name + ")");
return this.entityRenderer.transform(name, basicClass);
}
else if (checkName(name, "bzw", "net.minecraft.client.renderer.RenderItem"))
{
System.out.println("BBCoreMod: Transforming RenderItem class (" + name + ")");
return this.renderItem.transform(name, basicClass);
}
else if (checkName(name, "bzu", "net.minecraft.client.renderer.entity.RenderEntityItem"))
{
System.out.println("BBCoreMod: Transforming RenderItem class (" + name + ")");
return this.renderEntityItemTransformer.transform(name, basicClass);
}
else if (checkName(name, "acl", "net.minecraft.entity.item.EntityItem"))
{
System.out.println("BBCoreMod: Transforming EntityItem class (" + name + ")");
return this.entityItemTransformer.transform(name, basicClass);
}
else if (checkName(name, "aec", "net.minecraft.entity.player.InventoryPlayer"))
{
System.out.println("BBCoreMod: Transforming InventoryPlayer class (" + name + ")");
return this.inventoryPlayerTransformer.transform(name, basicClass);
}
return basicClass;
}
public static void debugInstructions(InsnList list)
{
debugInstructions(list, Integer.MAX_VALUE);
}
public static void debugInstructions(InsnList list, int max)
{
Iterator<AbstractInsnNode> nodes = list.iterator();
int i = 0;
while (nodes.hasNext())
{
AbstractInsnNode node = nodes.next();
System.out.println("Offset: " + i + " " + node.getClass().getSimpleName() + " " + debugNode(node));
if (i >= max)
{
break;
}
i++;
}
}
public static String debugNode(AbstractInsnNode node)
{
if (node instanceof LabelNode)
{
return "label " + ((LabelNode) node).getLabel().toString();
}
else if (node instanceof LineNumberNode)
{
return "line " + String.valueOf(((LineNumberNode) node).line);
}
else if (node instanceof MethodInsnNode)
{
MethodInsnNode method = (MethodInsnNode) node;
return method.getOpcode() + " " + method.owner + "." + method.name + ":" + method.desc;
}
else if (node instanceof FieldInsnNode)
{
FieldInsnNode field = (FieldInsnNode) node;
return field.getOpcode() + " " + field.owner + "." + field.name + ":" + field.desc;
}
else if (node instanceof VarInsnNode)
{
VarInsnNode var = (VarInsnNode) node;
return "opcode " + var.getOpcode() + " var " + var.var;
}
else if (node instanceof LdcInsnNode)
{
LdcInsnNode ldc = (LdcInsnNode) node;
return "LDC " + ldc.cst.toString();
}
return "opcode " + String.valueOf(node.getOpcode());
}
} | 6,076 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BBCoreModInfo.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/BBCoreModInfo.java | package mchorse.blockbuster.core;
import net.minecraftforge.fml.common.DummyModContainer;
public class BBCoreModInfo extends DummyModContainer
{
@Override
public String getName()
{
return "Blockbuster Core mod";
}
@Override
public String getModId()
{
return "blockbuster_core";
}
@Override
public Object getMod()
{
return null;
}
@Override
public String getVersion()
{
return "%VERSION%";
}
} | 493 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BBCoreMod.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/BBCoreMod.java | package mchorse.blockbuster.core;
import java.util.Map;
import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin.MCVersion;
import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin.Name;
import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin.SortingIndex;
@Name("BlockbusterCore")
@MCVersion("1.12.2")
@SortingIndex(1)
public class BBCoreMod implements IFMLLoadingPlugin
{
@Override
public String[] getASMTransformerClass()
{
return new String[] {BBCoreClassTransformer.class.getName()};
}
@Override
public String getModContainerClass()
{
return BBCoreModInfo.class.getName();
}
@Override
public String getSetupClass()
{
return null;
}
@Override
public void injectData(Map<String, Object> data)
{}
@Override
public String getAccessTransformerClass()
{
return null;
}
} | 951 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
InventoryPlayerTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/InventoryPlayerTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassMethodTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import net.minecraft.item.ItemStack;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import org.objectweb.asm.Opcodes;
import java.util.Iterator;
public class InventoryPlayerTransformer extends ClassMethodTransformer
{
public InventoryPlayerTransformer()
{
/* insert a hook before and after something is added to inventory */
this.setMcp("addItemStackToInventory", "(Lnet/minecraft/item/ItemStack;)Z");
this.setNotch("e", "(Laip;)Z");
}
@Override
public void processMethod(String name, MethodNode method)
{
InsnList list = method.instructions;
Iterator<AbstractInsnNode> it = list.iterator();
String inventoryPlayerClassName = CoreClassTransformer.get("Laec;", "Lnet/minecraft/entity/player/InventoryPlayer;");
while (it.hasNext())
{
AbstractInsnNode node = it.next();
/* only call in this method is this.add(...) -> search for ALOAD of this*/
if (node instanceof VarInsnNode && node.getOpcode() == Opcodes.ALOAD && ((VarInsnNode) node).var == 0)
{
MethodInsnNode beforeEvent = new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/events/PlayerHandler", "beforeItemStackAdd", "(" + inventoryPlayerClassName + ")V", false);
MethodInsnNode afterEvent = new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/events/PlayerHandler", "afterItemStackAdd", "(" + inventoryPlayerClassName + ")V", false);
InsnList preInstructions = new InsnList();
InsnList postInstructions = new InsnList();
preInstructions.add(beforeEvent);
preInstructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
postInstructions.add(new VarInsnNode(Opcodes.ISTORE, 2));
postInstructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
postInstructions.add(afterEvent);
postInstructions.add(new VarInsnNode(Opcodes.ILOAD, 2));
method.instructions.insert(node, preInstructions);
/* go to method call of this.add() */
while (it.hasNext())
{
AbstractInsnNode node2 = it.next();
if (node2 instanceof MethodInsnNode && node2.getOpcode() == Opcodes.INVOKEVIRTUAL)
{
method.instructions.insert(node2, postInstructions);
System.out.println("BBCoreMod: successfully patched InventoryPlayer!");
return;
}
}
}
}
}
}
| 2,998 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
WorldTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/WorldTransformer.java | package mchorse.blockbuster.core.transformers;
import java.util.Iterator;
import mchorse.blockbuster.utils.mclib.coremod.ClassMethodTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
public class WorldTransformer extends ClassMethodTransformer
{
public WorldTransformer()
{
this.setMcp("setBlockState", "(Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;I)Z");
this.setNotch("a", "(Let;Lawt;I)Z");
}
@Override
public void processMethod(String name, MethodNode method)
{
InsnList list = method.instructions;
Iterator<AbstractInsnNode> it = list.iterator();
int i = 0;
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (node.getOpcode() == Opcodes.IRETURN)
{
i++;
continue;
}
if (i == 2)
{
InsnList newList = new InsnList();
String desc = CoreClassTransformer.get("(Lamu;Let;Lawt;I)V", "(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/block/state/IBlockState;I)V");
newList.add(new VarInsnNode(Opcodes.ALOAD, 0));
newList.add(new VarInsnNode(Opcodes.ALOAD, 1));
newList.add(new VarInsnNode(Opcodes.ALOAD, 2));
newList.add(new VarInsnNode(Opcodes.ILOAD, 3));
newList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/recording/capturing/WorldEventListener", "setBlockState", desc, false));
list.insert(node, newList);
System.out.println("BBCoreMod: successfully patched setBlockState!");
break;
}
}
}
}
| 2,043 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
RenderEntityItemTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/RenderEntityItemTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.*;
/**
* \* User: Evanechecssss
* \* https://evanechecssss.github.io
* \
*/
public class RenderEntityItemTransformer extends ClassTransformer
{
@Override
public void process(String s, ClassNode classNode) {
for (MethodNode method : classNode.methods) {
String methodName = this.checkName(method, "a", "(Lvg;DDDFF)V", "doRender", "(Lnet/minecraft/entity/item/EntityItem;DDDFF)V");
if (methodName != null) {
this.processMethod(methodName, method);
}
}
}
public void processMethod(String methodName, MethodNode method)
{
InsnList list = new InsnList();
list.add(new FieldInsnNode(Opcodes.GETSTATIC, "net/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType", "GROUND", "Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;"));
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "setTSRTTransform", "(Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;)V", false));
method.instructions.insert(list);
}
} | 1,324 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
RenderItemTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/RenderItemTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import mchorse.blockbuster.utils.mclib.coremod.ClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.*;
import java.util.Iterator;
public class RenderItemTransformer extends ClassTransformer
{
@Override
public void process(String s, ClassNode classNode)
{
for (MethodNode method : classNode.methods)
{
String methodName = this.checkName(method, "a", "(Laip;Lvp;Lbwc$b;Z)V", "renderItem", "(Lnet/minecraft/item/ItemStack;Lnet/minecraft/entity/EntityLivingBase;Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;Z)V");
if (methodName != null)
{
this.processRenderItemMethod(methodName,method);
}
methodName = this.checkName(method,"a","(Laip;Lcfy;Lbwc$b;Z)V","renderItemModel", "(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/renderer/block/model/IBakedModel;Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;Z)V");
if (methodName != null)
{
this.processRenderItemModel(methodName,method);
}
methodName = this.checkName(method,"a","(Laip;Lbwc$b;)V","renderItem", "(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;)V");
if (methodName != null)
{
this.processRenderItem(methodName,method);
}
methodName = this.checkName(method,"a","(Laip;IILcfy;)V","renderItemModelIntoGUI", "(Lnet/minecraft/item/ItemStack;IILnet/minecraft/client/renderer/block/model/IBakedModel;)V");
if (methodName != null)
{
this.processRenderItemModelInGUI(methodName,method);
}
}
}
public void processRenderItemMethod(String methodName, MethodNode method)
{
String entity = CoreClassTransformer.obfuscated ? "Lvp;" : "Lnet/minecraft/entity/EntityLivingBase;";
String transform = CoreClassTransformer.obfuscated ? "Lbwc$b;" : "Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;";
InsnList before = new InsnList();
before.add(new VarInsnNode(Opcodes.ALOAD, 2));
before.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "setLastItemHolder", "(" + entity + ")V", false));
method.instructions.insert(before);
InsnList midle = new InsnList();
midle.add(new VarInsnNode(Opcodes.ALOAD, 3));
midle.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler",
"setTSRTTransform", "(" + transform+ ")V", false));
method.instructions.insert(midle);
InsnList after = new InsnList();
after.add(new VarInsnNode(Opcodes.ALOAD, 2));
after.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "resetLastItemHolder", "(" + entity + ")V", false));
AbstractInsnNode target = null;
Iterator<AbstractInsnNode> it = method.instructions.iterator();
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (node.getOpcode() == Opcodes.RETURN)
{
target = node;
break;
}
}
if (target != null)
{
method.instructions.insertBefore(target, after);
System.out.println("BBCoreMod: successfully patched renderItem!");
}
}
public void processRenderItem(String methodName, MethodNode method)
{
String transform = CoreClassTransformer.obfuscated ? "Lbwc$b;" : "Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;";
InsnList before = new InsnList();
before.add(new VarInsnNode(Opcodes.ALOAD, 2));
before.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler",
"setTSRTTransform", "(" + transform+ ")V", false));
method.instructions.insert(before);
}
public void processRenderItemModel(String methodName, MethodNode method)
{
String transform = CoreClassTransformer.obfuscated ? "Lbwc$b;" : "Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;";
InsnList before = new InsnList();
before.add(new VarInsnNode(Opcodes.ALOAD, 3));
before.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler",
"setTSRTTransform", "(" + transform+ ")V", false));
method.instructions.insert(before);
}
public void processRenderItemModelInGUI(String methodName, MethodNode method)
{
InsnList list = new InsnList();
list.add(new FieldInsnNode(Opcodes.GETSTATIC, "net/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType", "GUI", "Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;"));
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "setTSRTTransform", "(Lnet/minecraft/client/renderer/block/model/ItemCameraTransforms$TransformType;)V", false));
method.instructions.insert(list);
}
} | 5,496 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
RenderPlayerTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/RenderPlayerTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassMethodTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import java.util.Iterator;
/**
* \* User: Evanechecssss
* \* https://evanechecssss.github.io
* \
*/
public class RenderPlayerTransformer extends ClassMethodTransformer
{
public RenderPlayerTransformer()
{
super();
this.setMcp("setModelVisibilities", "(Lnet/minecraft/client/entity/AbstractClientPlayer;)V");
this.setNotch("d", "(Lbua;)V");
}
@Override
public void processMethod(String name, MethodNode method)
{
String player = CoreClassTransformer.obfuscated ? "Lbua;" : "Lnet/minecraft/client/entity/AbstractClientPlayer;";
String model = CoreClassTransformer.obfuscated ? "Lbqj;" : "Lnet/minecraft/client/model/ModelPlayer;";
//INSTRUCTIONS
InsnList list = new InsnList();
list.add(new VarInsnNode(Opcodes.ALOAD, 1));
list.add(new VarInsnNode(Opcodes.ALOAD, 2));
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "changePlayerHand", "(" + player + "" + model + ")V", false));
//INSTRUCTION ITERATIONS
Iterator<AbstractInsnNode> it = method.instructions.iterator();
AbstractInsnNode target = null;
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (node.getOpcode() == Opcodes.RETURN)
{
target = node;
break;
}
}
//INVOKING
if (target != null)
{
method.instructions.insertBefore(target, list);
}
}
} | 1,989 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
EntityItemTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/EntityItemTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassMethodTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import java.util.Iterator;
public class EntityItemTransformer extends ClassMethodTransformer
{
public EntityItemTransformer()
{
/*
* insert a hook right before item is added and forge's item pickup event is called
* this is used to prevent item pick up during first person playback
*/
this.setMcp("onCollideWithPlayer", "(Lnet/minecraft/entity/player/EntityPlayer;)V");
this.setNotch("d", "(Laed;)V");
}
@Override
public void processMethod(String name, MethodNode method)
{
InsnList list = method.instructions;
Iterator<AbstractInsnNode> it = list.iterator();
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (node instanceof VarInsnNode)
{
VarInsnNode varInsnNode = (VarInsnNode) node;
/*
* ItemStack clone = itemstack.copy(); is stored at place 6
* this is right before item is added to inventory in the if statement
*/
if (varInsnNode.getOpcode() == Opcodes.ASTORE && varInsnNode.var == 6)
{
VarInsnNode loadEntityPlayerArg = new VarInsnNode(Opcodes.ALOAD, 1);
/* load itemStack variable (ItemStack itemStack = this.getItem();*/
VarInsnNode loadItemStack = new VarInsnNode(Opcodes.ALOAD, 2);
String itemStackClassName = CoreClassTransformer.get("Laed;Laip;", "Lnet/minecraft/entity/player/EntityPlayer;Lnet/minecraft/item/ItemStack;");
method.instructions.insert(varInsnNode, loadEntityPlayerArg);
method.instructions.insert(loadEntityPlayerArg, loadItemStack);
method.instructions.insert(loadItemStack, new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/events/PlayerHandler", "beforePlayerItemPickUp", "(" + itemStackClassName + ")V", false));
System.out.println("BBCoreMod: successfully patched EntityItem!");
return;
}
}
}
}
}
| 2,586 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
EntityTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/EntityTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldNode;
import org.objectweb.asm.tree.FieldInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
/**
* This patches the entity to save the position before the previous position.
* The reason for this is to be able to calculate acceleration - the difference of previous velocity and current velocity
* @author Christian F. (known as Chryfi)
*/
public class EntityTransformer extends ClassTransformer
{
@Override
public void process(String s, ClassNode node)
{
FieldNode prevPrevPosX = new FieldNode(Opcodes.ASM4, Opcodes.ACC_PUBLIC, "prevPrevPosX", "D", null, null);
FieldNode prevPrevPosY = new FieldNode(Opcodes.ASM4, Opcodes.ACC_PUBLIC, "prevPrevPosY", "D", null, null);
FieldNode prevPrevPosZ = new FieldNode(Opcodes.ASM4, Opcodes.ACC_PUBLIC, "prevPrevPosZ", "D", null, null);
node.fields.add(prevPrevPosX);
node.fields.add(prevPrevPosY);
node.fields.add(prevPrevPosZ);
for (MethodNode method : node.methods)
{
String methodName = this.checkName(method, "Y", "()V", "onEntityUpdate", "()V");
if (methodName != null)
{
this.processOnEntityUpdate(method);
break;
}
}
System.out.println("BBCoreMod: successfully patched Entities!");
}
public void processOnEntityUpdate(MethodNode method)
{
InsnList list = new InsnList();
String entity = CoreClassTransformer.get("vg", "net/minecraft/entity/Entity");
String prevPosX = CoreClassTransformer.get("m", "prevPosX");
String prevPosY = CoreClassTransformer.get("n", "prevPosY");
String prevPosZ = CoreClassTransformer.get("o", "prevPosZ");
buildFieldAssignmentInsn(list, entity, prevPosX, "prevPrevPosX");
buildFieldAssignmentInsn(list, entity, prevPosY, "prevPrevPosY");
buildFieldAssignmentInsn(list, entity, prevPosZ, "prevPrevPosZ");
method.instructions.insert(this.getFirstLabel(method), list);
System.out.println("BBCoreMod: successfully patched onEntityUpdate!");
}
public void buildFieldAssignmentInsn(InsnList list, String owner, String get, String put)
{
list.add(new VarInsnNode(Opcodes.ALOAD, 0));
list.add(new VarInsnNode(Opcodes.ALOAD, 0));
list.add(new FieldInsnNode(Opcodes.GETFIELD, owner, get, "D"));
list.add(new FieldInsnNode(Opcodes.PUTFIELD, owner, put, "D"));
}
} | 2,846 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
RenderGlobalTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/RenderGlobalTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.InsnNode;
import org.objectweb.asm.tree.JumpInsnNode;
import org.objectweb.asm.tree.LabelNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import java.util.Iterator;
public class RenderGlobalTransformer extends ClassTransformer
{
@Override
public void process(String name, ClassNode node)
{
for (MethodNode method : node.methods)
{
String methodName = this.checkName(method, "a", "(FI)V", "renderSky", "(FI)V");
if (methodName != null)
{
this.processRenderSky(method);
}
methodName = this.checkName(method, "a", "(FIDDD)V", "renderClouds", "(FIDDD)V");
if (methodName != null)
{
this.processRenderClouds(method);
}
methodName = this.checkName(method, "a", "(Lvg;Lbxy;F)V", "renderEntities", "(Lnet/minecraft/entity/Entity;Lnet/minecraft/client/renderer/culling/ICamera;F)V");
if (methodName != null)
{
this.processRenderEntities(method);
}
}
}
private void processRenderSky(MethodNode method)
{
LabelNode label = this.getFirstLabel(method);
if (label != null)
{
InsnList list = new InsnList();
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "isGreenSky", "()Z", false));
list.add(new JumpInsnNode(Opcodes.IFEQ, label));
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "renderGreenSky", "()V", false));
list.add(new InsnNode(Opcodes.RETURN));
method.instructions.insert(list);
System.out.println("BBCoreMod: successfully patched renderSky!");
}
}
private void processRenderClouds(MethodNode method)
{
LabelNode label = this.getFirstLabel(method);
if (label != null)
{
InsnList list = new InsnList();
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "isGreenSky", "()Z", false));
list.add(new JumpInsnNode(Opcodes.IFEQ, label));
list.add(new InsnNode(Opcodes.RETURN));
method.instructions.insert(list);
System.out.println("BBCoreMod: successfully patched renderClouds!");
}
}
private void processRenderEntities(MethodNode method)
{
LabelNode releaseLabel = null;
LabelNode renderEntityLabel = null;
LabelNode lastLabel = null;
boolean captureNext = false;
int renderCounter = 0;
Iterator<AbstractInsnNode> it = method.instructions.iterator();
boolean insertedRenderLastCall = false;
boolean foundAllForAddEntitiesHook = false;
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (!foundAllForAddEntitiesHook && node instanceof LabelNode)
{
lastLabel = (LabelNode) node;
if (captureNext && renderEntityLabel == null)
{
renderEntityLabel = lastLabel;
captureNext = false;
}
}
if (node instanceof MethodInsnNode)
{
MethodInsnNode methodInsnNode = (MethodInsnNode) node;
if (!foundAllForAddEntitiesHook)
{
if (CoreClassTransformer.checkName(methodInsnNode.owner, "bzf", "net/minecraft/client/renderer/entity/RenderManager")
&& CoreClassTransformer.checkName(methodInsnNode.name, "a", "renderEntityStatic")
&& CoreClassTransformer.checkName(methodInsnNode.desc, "(Lvg;FZ)V", "(Lnet/minecraft/entity/Entity;FZ)V"))
{
if (renderCounter == 1)
{
captureNext = true;
}
renderCounter += 1;
}
if (CoreClassTransformer.checkName(methodInsnNode.owner, "et$b", "net/minecraft/util/math/BlockPos$PooledMutableBlockPos")
&& CoreClassTransformer.checkName(methodInsnNode.name, "t", "release")
&& methodInsnNode.desc.equals("()V"))
{
releaseLabel = lastLabel;
foundAllForAddEntitiesHook = true;
}
}
/* this should indicate the end of the method renderEntities (postRenderDamagedBlocks is the 3rd method before end) */
if (CoreClassTransformer.checkName(methodInsnNode.owner, "buy", "net/minecraft/client/renderer/RenderGlobal")
&& CoreClassTransformer.checkName(methodInsnNode.name, "v", "postRenderDamagedBlocks")
&& methodInsnNode.desc.equals("()V"))
{
/* Render last entities after postRenderDamagedBlocks to avoid OpenGL states that were meant for damagedBlocks */
method.instructions.insert(methodInsnNode, new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "renderLastEntities", "()V", false));
insertedRenderLastCall = true;
break;
}
}
}
if (renderEntityLabel != null && releaseLabel != null)
{
/* In non-Optifine Minecraft, the index of the entity variable is 27,
* however due to Optifine modifications, it's another index, but it
* should be the last local variable... */
final String entity = CoreClassTransformer.get("Lvg;", "Lnet/minecraft/entity/Entity;");
int localIndex = 0;
for (LocalVariableNode var : method.localVariables)
{
if (var.desc.equals(entity))
{
localIndex = Math.max(localIndex, var.index);
}
}
/* Add render entity */
InsnList list = new InsnList();
list.add(new VarInsnNode(Opcodes.ALOAD, localIndex));
list.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "addRenderedEntity", "(" + entity + ")V", false));
/* avoid memory leak - if renderLast method is not called, the list of rendered entities would not be cleared */
if (insertedRenderLastCall)
{
method.instructions.insert(renderEntityLabel, list);
System.out.println("BBCoreMod: successfully patched renderEntities!");
}
}
}
} | 7,310 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
EntityRendererTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/EntityRendererTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassMethodTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.InsnList;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
import org.objectweb.asm.tree.VarInsnNode;
import java.util.Iterator;
public class EntityRendererTransformer extends ClassMethodTransformer
{
public EntityRendererTransformer()
{
super();
this.setMcp("renderWorldPass", "(IFJ)V");
this.setNotch("a", "(IFJ)V");
}
@Override
public void processMethod(String s, MethodNode methodNode)
{
AbstractInsnNode renderLitNode = null;
AbstractInsnNode renderNode = null;
String owner = CoreClassTransformer.obfuscated ? "btg" : "net/minecraft/client/particle/ParticleManager";
String renderLit = CoreClassTransformer.obfuscated ? "b" : "renderLitParticles";
String render = CoreClassTransformer.obfuscated ? "a" : "renderParticles";
String desc = CoreClassTransformer.obfuscated ? "(Lvg;F)V" : "(Lnet/minecraft/entity/Entity;F)V";
/* Find these alive */
Iterator<AbstractInsnNode> it = methodNode.instructions.iterator();
while (it.hasNext())
{
AbstractInsnNode node = it.next();
if (node.getOpcode() == Opcodes.INVOKEVIRTUAL)
{
MethodInsnNode invoke = (MethodInsnNode) node;
if (invoke.owner.equals(owner) && invoke.desc.equals(desc))
{
if (invoke.name.equals(renderLit))
{
renderLitNode = node;
}
else if (invoke.name.equals(render))
{
renderNode = node;
}
}
}
}
if (renderLitNode != null && renderNode != null)
{
InsnList renderLitList = new InsnList();
InsnList rendeList = new InsnList();
renderLitList.add(new VarInsnNode(Opcodes.FLOAD, 2));
renderLitList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "renderLitParticles", "(F)V", false));
rendeList.add(new VarInsnNode(Opcodes.FLOAD, 2));
rendeList.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "mchorse/blockbuster/client/RenderingHandler", "renderParticles", "(F)V", false));
methodNode.instructions.insert(renderLitNode, renderLitList);
methodNode.instructions.insert(renderNode, rendeList);
System.out.println("BBCoreMod: successfully patched renderWorldPass!");
}
else
{
System.out.println("BBCoreMod: failed to find particle nodes: " + renderLitNode + " and " +renderNode);
}
}
} | 3,024 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
EntityTransformationUtilsTransformer.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/core/transformers/EntityTransformationUtilsTransformer.java | package mchorse.blockbuster.core.transformers;
import mchorse.blockbuster.utils.mclib.coremod.ClassTransformer;
import mchorse.blockbuster.utils.mclib.coremod.CoreClassTransformer;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.*;
import java.util.Iterator;
public class EntityTransformationUtilsTransformer extends ClassTransformer
{
@Override
public void process(String s, ClassNode node)
{
for (MethodNode method : node.methods)
{
String entityDesc = "Lnet/minecraft/entity/Entity;";
if (method.name.equals("getPrevPrevPosX") && method.desc.equals("("+entityDesc+")D"))
{
this.processGetPrevPrevPos(method, "X");
}
else if (method.name.equals("getPrevPrevPosY") && method.desc.equals("("+entityDesc+")D"))
{
this.processGetPrevPrevPos(method, "Y");
}
else if (method.name.equals("getPrevPrevPosZ") && method.desc.equals("("+entityDesc+")D"))
{
this.processGetPrevPrevPos(method, "Z");
}
}
System.out.println("BBCoreMod: successfully patched EntityTransformationUtils!");
}
public void processGetPrevPrevPos(MethodNode method, String axis)
{
Iterator<AbstractInsnNode> it = method.instructions.iterator();
AbstractInsnNode target = null;
int index = -1;
while (it.hasNext())
{
index++;
AbstractInsnNode node = it.next();
if (node instanceof InsnNode)
{
if (node.getOpcode() == Opcodes.DCONST_0)
{
target = node;
break;
}
}
}
method.instructions.remove(target);
target = method.instructions.get(index-1);
InsnList list = new InsnList();
list.add(new VarInsnNode(Opcodes.ALOAD, 0));
list.add(new FieldInsnNode(Opcodes.GETFIELD, CoreClassTransformer.get("vg", "net/minecraft/entity/Entity"), "prevPrevPos"+axis, "D"));
method.instructions.insert(target, list);
System.out.println("BBCoreMod: successfully patched getPrevPrevPos"+axis+"!");
}
}
| 2,254 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandRecord.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandRecord.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.aperture.CameraHandler;
import mchorse.blockbuster.commands.record.SubCommandRecordAdd;
import mchorse.blockbuster.commands.record.SubCommandRecordApply;
import mchorse.blockbuster.commands.record.SubCommandRecordCalculateBodyYaw;
import mchorse.blockbuster.commands.record.SubCommandRecordCamera;
import mchorse.blockbuster.commands.record.SubCommandRecordClean;
import mchorse.blockbuster.commands.record.SubCommandRecordCreate;
import mchorse.blockbuster.commands.record.SubCommandRecordCut;
import mchorse.blockbuster.commands.record.SubCommandRecordDelete;
import mchorse.blockbuster.commands.record.SubCommandRecordDupe;
import mchorse.blockbuster.commands.record.SubCommandRecordErase;
import mchorse.blockbuster.commands.record.SubCommandRecordFade;
import mchorse.blockbuster.commands.record.SubCommandRecordFill;
import mchorse.blockbuster.commands.record.SubCommandRecordFlip;
import mchorse.blockbuster.commands.record.SubCommandRecordGet;
import mchorse.blockbuster.commands.record.SubCommandRecordInfo;
import mchorse.blockbuster.commands.record.SubCommandRecordMerge;
import mchorse.blockbuster.commands.record.SubCommandRecordOrigin;
import mchorse.blockbuster.commands.record.SubCommandRecordProcess;
import mchorse.blockbuster.commands.record.SubCommandRecordProlong;
import mchorse.blockbuster.commands.record.SubCommandRecordRemove;
import mchorse.blockbuster.commands.record.SubCommandRecordRemoveAll;
import mchorse.blockbuster.commands.record.SubCommandRecordRemoveBodyYaw;
import mchorse.blockbuster.commands.record.SubCommandRecordRename;
import mchorse.blockbuster.commands.record.SubCommandRecordRestore;
import mchorse.blockbuster.commands.record.SubCommandRecordReverse;
import mchorse.blockbuster.commands.record.SubCommandRecordSearch;
import mchorse.blockbuster.commands.record.SubCommandRecordTP;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.commands.utils.L10n;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import java.io.FileNotFoundException;
/**
* Command /record
*
* This command provides an interface which allows the manipulation of player
* recordings on the server.
*/
public class CommandRecord extends SubCommandBase
{
public CommandRecord()
{
/* Register sub-commands */
this.add(new SubCommandRecordAdd());
this.add(new SubCommandRecordApply());
this.add(new SubCommandRecordCalculateBodyYaw());
if (CameraHandler.isApertureLoaded())
{
this.add(new SubCommandRecordCamera());
}
this.add(new SubCommandRecordClean());
this.add(new SubCommandRecordCreate());
this.add(new SubCommandRecordCut());
this.add(new SubCommandRecordDupe());
this.add(new SubCommandRecordErase());
this.add(new SubCommandRecordFade());
this.add(new SubCommandRecordFill());
this.add(new SubCommandRecordFlip());
this.add(new SubCommandRecordGet());
this.add(new SubCommandRecordInfo());
this.add(new SubCommandRecordMerge());
this.add(new SubCommandRecordOrigin());
this.add(new SubCommandRecordProcess());
this.add(new SubCommandRecordProlong());
this.add(new SubCommandRecordDelete());
this.add(new SubCommandRecordRemove());
this.add(new SubCommandRecordRemoveAll());
this.add(new SubCommandRecordDelete());
this.add(new SubCommandRecordRemoveBodyYaw());
this.add(new SubCommandRecordRename());
this.add(new SubCommandRecordRestore());
this.add(new SubCommandRecordReverse());
this.add(new SubCommandRecordSearch());
this.add(new SubCommandRecordTP());
}
@Override
public L10n getL10n()
{
return Blockbuster.l10n;
}
@Override
public String getName()
{
return "record";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.help";
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
/**
* Get record by given filename
*
* This is a command-friendly method for retrieving a player recording. In
* case of error, {@link CommandException} will be thrown.
*/
public static Record getRecord(String filename) throws CommandException
{
try
{
return CommonProxy.manager.get(filename);
}
catch (FileNotFoundException e)
{
throw new CommandException("record.not_exist", filename);
}
catch (Exception e)
{
e.printStackTrace();
throw new CommandException("recording.read", filename);
}
}
} | 4,962 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandAction.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandAction.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.action.SubCommandActionAppend;
import mchorse.blockbuster.commands.action.SubCommandActionCancel;
import mchorse.blockbuster.commands.action.SubCommandActionClear;
import mchorse.blockbuster.commands.action.SubCommandActionPlay;
import mchorse.blockbuster.commands.action.SubCommandActionRecord;
import mchorse.blockbuster.commands.action.SubCommandActionRequest;
import mchorse.blockbuster.commands.action.SubCommandActionStop;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.commands.utils.L10n;
import mchorse.metamorph.api.MorphManager;
import mchorse.metamorph.api.morphs.AbstractMorph;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.nbt.JsonToNBT;
import net.minecraft.world.World;
/**
* Command /action
*
* This command is responsible for recording player actions or playbacking
* already recorded player actions.
*
* This command is merged version of CommandPlay and CommandRecord (which both
* were removed in 1.1). These commands were merged together, because they had
* similar signature and work with player recordings.
*
* In 1.4, this command was refactored into {@link SubCommandBase} command.
*/
public class CommandAction extends SubCommandBase
{
public CommandAction()
{
/* Register sub-commands in alphabetical order */
this.add(new SubCommandActionAppend());
this.add(new SubCommandActionCancel());
this.add(new SubCommandActionClear());
this.add(new SubCommandActionPlay());
this.add(new SubCommandActionRecord());
this.add(new SubCommandActionRequest());
this.add(new SubCommandActionStop());
}
@Override
public L10n getL10n()
{
return Blockbuster.l10n;
}
@Override
public String getName()
{
return "action";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.help";
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
/**
* Create an actor from command line arguments (i.e. String array).
* Description of every element in array:
*
* 1. Ignored (since it's filename)
* 2. Invincible flag (boolean)
* 3+. NBT data of the morph
*
* And of course, all of those arguments are optional (i.e. have default
* values).
*/
public static EntityActor actorFromArgs(String[] args, World world) throws CommandException
{
EntityActor actor;
AbstractMorph morph = null;
boolean invincible = args.length >= 2 && CommandBase.parseBoolean(args[1]);
String model = args.length >= 3 ? String.join(" ",SubCommandBase.dropFirstArguments(args, 2)) : null;
if (model != null)
{
try
{
morph = MorphManager.INSTANCE.morphFromNBT(JsonToNBT.getTagFromJson(model));
}
catch (Exception e)
{}
}
actor = new EntityActor(world);
actor.modify(morph, false, true);
actor.setEntityInvulnerable(invincible);
return actor;
}
} | 3,389 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandMount.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandMount.java | package mchorse.blockbuster.commands;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.Entity;
import net.minecraft.server.MinecraftServer;
public class CommandMount extends BBCommandBase
{
@Override
public String getName()
{
return "mount";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.mount.help";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}mount {8}<target>{r} {7}[destination]{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Entity target = getEntity(server, sender, args[0]);
if (args.length > 1)
{
target.startRiding(getEntity(server, sender, args[1]));
}
else
{
target.dismountRidingEntity();
}
}
}
| 1,072 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandDamage.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandDamage.java | package mchorse.blockbuster.commands;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.DamageSource;
public class CommandDamage extends BBCommandBase
{
@Override
public String getName()
{
return "damage";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.damage.help";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}damage {7}<entity> <amount>{r}";
}
@Override
public boolean isUsernameIndex(String[] args, int index)
{
return index == 0;
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
float damage = (float) CommandBase.parseDouble(args[1]);
Entity entity = getEntity(server, sender, args[0]);
if (damage < 0 && entity instanceof EntityLivingBase)
{
EntityLivingBase target = (EntityLivingBase) entity;
target.setHealth(target.getHealth() + Math.abs(damage));
}
else if (damage > 0)
{
entity.attackEntityFrom(DamageSource.OUT_OF_WORLD, damage);
}
}
}
| 1,607 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandSpectate.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandSpectate.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.EntitySelector;
import net.minecraft.command.ICommandSender;
import net.minecraft.command.WrongUsageException;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.GameType;
import java.util.List;
/**
* Spectate entity command - /spectate <player> <entity>
*
* This command allows to make given player a spectator of given entity.
* I don't know why it's useful, but I think this can be useful.
*/
public class CommandSpectate extends BBCommandBase
{
@Override
public String getName()
{
return "spectate";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.spectate.help";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}spectate {8}<player>{r} {7}<entity>{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getPlayer(server, sender, args[0]);
if (player == null)
{
Blockbuster.l10n.error(sender, "commands.no_player", args[0]);
return;
}
List<Entity> entities = EntitySelector.matchEntities(sender, args[1], Entity.class);
if (entities.isEmpty())
{
Blockbuster.l10n.error(sender, "commands.no_entity", args[1]);
return;
}
if (!player.isSpectator())
{
player.setGameType(GameType.SPECTATOR);
}
for (Entity entity : entities)
{
if (entity != player)
{
player.setSpectatingEntity(entity);
break;
}
}
}
/**
* Provide completion for player usernames for first argument
*/
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, server.getOnlinePlayerNames());
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 2,571 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandModel.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandModel.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.model.SubCommandModelClear;
import mchorse.blockbuster.commands.model.SubCommandModelClearStructures;
import mchorse.blockbuster.commands.model.SubCommandModelCombine;
import mchorse.blockbuster.commands.model.SubCommandModelConvertSkin;
import mchorse.blockbuster.commands.model.SubCommandModelExport;
import mchorse.blockbuster.commands.model.SubCommandModelExportObj;
import mchorse.blockbuster.commands.model.SubCommandModelReload;
import mchorse.blockbuster.commands.model.SubCommandModelReport;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.commands.utils.L10n;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /model
*
* Another client-side command which is responsible for
*/
public class CommandModel extends SubCommandBase
{
/**
* Model command's constructor
*
* This method is responsible for attaching sub commands for this model
*/
public CommandModel()
{
this.add(new SubCommandModelClear());
this.add(new SubCommandModelClearStructures());
this.add(new SubCommandModelCombine());
this.add(new SubCommandModelConvertSkin());
this.add(new SubCommandModelExport());
this.add(new SubCommandModelExportObj());
this.add(new SubCommandModelReload());
this.add(new SubCommandModelReport());
}
@Override
public L10n getL10n()
{
return Blockbuster.l10n;
}
@Override
public String getName()
{
return "model";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.model.help";
}
@Override
public String getSyntax()
{
return "";
}
@Override
public boolean checkPermission(MinecraftServer server, ICommandSender sender)
{
return true;
}
} | 1,995 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
BBCommandBase.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/BBCommandBase.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.mclib.commands.McCommandBase;
import mchorse.mclib.commands.utils.L10n;
public abstract class BBCommandBase extends McCommandBase
{
@Override
public L10n getL10n()
{
return Blockbuster.l10n;
}
}
| 314 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandModelBlock.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandModelBlock.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.modelblock.SubCommandModelBlockMorph;
import mchorse.blockbuster.commands.modelblock.SubCommandModelBlockProperty;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.commands.utils.L10n;
import net.minecraft.command.ICommandSender;
public class CommandModelBlock extends SubCommandBase
{
public CommandModelBlock()
{
this.add(new SubCommandModelBlockMorph());
this.add(new SubCommandModelBlockProperty());
}
@Override
public L10n getL10n()
{
return Blockbuster.l10n;
}
@Override
public String getName()
{
return "modelblock";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.modelblock.help";
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
} | 960 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandItemNBT.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandItemNBT.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.command.WrongUsageException;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import javax.annotation.Nullable;
import java.util.List;
public class CommandItemNBT extends BBCommandBase
{
@Override
public String getName()
{
return "item_nbt";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.item_nbt.help";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}item_nbt {7}<give_command>{r}";
}
@Override
public boolean checkPermission(MinecraftServer server, ICommandSender sender)
{
return true;
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
ItemStack stack = Minecraft.getMinecraft().player.getHeldItemMainhand();
if (stack.isEmpty())
{
Blockbuster.l10n.error(sender, "commands.item_nbt_empty");
return;
}
boolean command = CommandBase.parseBoolean(args[0]);
String output = "{}";
if (command)
{
NBTTagCompound tag = new NBTTagCompound();
stack.writeToNBT(tag);
output = "/give @p " + tag.getString("id") + " " + stack.getCount() + " " + stack.getItemDamage();
if (stack.hasTagCompound())
{
output += " " + stack.getTagCompound().toString();
}
}
else if (stack.hasTagCompound())
{
output = stack.getTagCompound().toString();
}
GuiScreen.setClipboardString(output);
Blockbuster.l10n.success(sender, "commands.item_nbt");
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, @Nullable BlockPos targetPos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, BOOLEANS);
}
return super.getTabCompletions(server, sender, args, targetPos);
}
} | 2,576 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandOnHead.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandOnHead.java | package mchorse.blockbuster.commands;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.EntityEquipmentSlot;
import net.minecraft.item.ItemStack;
import net.minecraft.server.MinecraftServer;
public class CommandOnHead extends CommandBase
{
@Override
public String getName()
{
return "on_head";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.on_head.help";
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
@Override
public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayer player = getCommandSenderAsPlayer(sender);
ItemStack stack = player.getHeldItemMainhand();
if (!stack.isEmpty())
{
player.setItemStackToSlot(EntityEquipmentSlot.HEAD, stack.copy());
}
}
} | 1,092 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
CommandScene.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/CommandScene.java | package mchorse.blockbuster.commands;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.recording.scene.Scene;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.command.WrongUsageException;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
/**
* Command /scene
*
* This command is responsible for playing or stopping scenes.
*/
public class CommandScene extends BBCommandBase
{
@Override
public String getName()
{
return "scene";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.scene";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}scene {8}<play|toggle|stop|loop>{r} {7}<name> [flag]{r}";
}
@Override
public int getRequiredPermissionLevel()
{
return 2;
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
if (args.length < 2)
{
throw new WrongUsageException(this.getUsage(null));
}
String action = args[0];
String name = args[1];
Scene scene = CommonProxy.scenes.get(name, sender.getEntityWorld());
if (scene == null)
{
Blockbuster.l10n.error(sender, "scene.no_scene", name);
return;
}
String play = "scene.play";
String stop = "scene.stop";
if (action.equals("play"))
{
if (scene.playing)
{
Blockbuster.l10n.error(sender, "scene.playing", name);
return;
}
scene.startPlayback(0);
Blockbuster.l10n.success(sender, play, name);
}
else if (action.equals("stop"))
{
if (!scene.playing)
{
Blockbuster.l10n.error(sender, "scene.stopped", name);
return;
}
scene.stopPlayback(true);
Blockbuster.l10n.success(sender, stop, name);
}
else if (action.equals("loop") && args.length >= 2)
{
scene.loops = CommandBase.parseBoolean(args[2]);
try
{
CommonProxy.scenes.save(scene.getId(), scene);
Blockbuster.l10n.info(sender, "scene." + (scene.loops ? "looped" : "unlooped"));
}
catch (Exception e)
{}
}
else if (action.equals("toggle"))
{
boolean isPlaying = scene.togglePlayback();
Blockbuster.l10n.success(sender, isPlaying ? play : stop, name);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, "play", "stop", "toggle", "loop");
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 3,285 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionAppend.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionAppend.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.recording.data.Mode;
import mchorse.blockbuster.recording.scene.Scene;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
/**
* Sub-command /action append
*
* This sub-command is responsible for starting recording given
*/
public class SubCommandActionAppend extends BBCommandBase
{
@Override
public String getName()
{
return "append";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.append";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}append{r} {7}<filename> <offset> [scene]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
int offset = CommandBase.parseInt(args[1], 0);
if (args.length >= 3)
{
Scene scene = CommonProxy.scenes.get(args[2], sender.getEntityWorld());
if (scene != null)
{
CommonProxy.scenes.record(args[2], args[0], offset, player);
}
}
else
{
CommonProxy.manager.record(args[0], player, Mode.ACTIONS, true, true, offset, null);
}
}
} | 1,725 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionCancel.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionCancel.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
public class SubCommandActionCancel extends BBCommandBase
{
@Override
public String getName()
{
return "cancel";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.cancel";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}cancel{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
if (CommonProxy.manager.cancel(player))
{
Blockbuster.l10n.info(sender, "action.cancel");
}
}
} | 1,080 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionRequest.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionRequest.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.recording.RecordUtils;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Sub-command /action request
*
* This command is responsible for requesting record frames from the server
*/
public class SubCommandActionRequest extends BBCommandBase
{
@Override
public String getName()
{
return "request";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.request";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}request{r} {7}<filename>{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
CommonProxy.scenes.play(args[0], sender.getEntityWorld());
RecordUtils.sendRecordTo(args[0], getCommandSenderAsPlayer(sender));
}
} | 1,205 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionRecord.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionRecord.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.recording.data.Mode;
import mchorse.blockbuster.recording.scene.Scene;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
/**
* Sub-command /action record
*
* This sub-command is responsible for starting recording given filename'd
* action with optionally provided scene.
*/
public class SubCommandActionRecord extends BBCommandBase
{
@Override
public String getName()
{
return "record";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.record";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}record{r} {7}<filename> [scene]{7}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
if (args.length >= 2)
{
Scene scene = CommonProxy.scenes.get(args[1], sender.getEntityWorld());
if (scene != null)
{
CommonProxy.scenes.record(args[1], args[0], player);
}
}
else
{
CommonProxy.manager.record(args[0], player, Mode.ACTIONS, true, true, null);
}
}
} | 1,656 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionClear.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionClear.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.capabilities.recording.Recording;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.network.Dispatcher;
import mchorse.blockbuster.network.common.recording.PacketUnloadRecordings;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
/**
* Sub-command /action clear
*
* This sub-command is responsible for clearing out tracking information about
* the player records on the server and also sending a packet for unloading the
* records on the client.
*
* Used in some buggy situations when server doesn't send unload packet or
* doesn't want to send clients a new record.
*/
public class SubCommandActionClear extends BBCommandBase
{
@Override
public String getName()
{
return "clear";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.clear";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}clear{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
Recording.get(player).removeRecordings();
Dispatcher.sendTo(new PacketUnloadRecordings(), player);
}
} | 1,516 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionStop.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionStop.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Sub-command /action stop
*
* This sub-command is responsible for stopping the action recording of current
* player.
*/
public class SubCommandActionStop extends BBCommandBase
{
@Override
public String getName()
{
return "stop";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.stop";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}stop{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
CommonProxy.manager.halt(getCommandSenderAsPlayer(sender), false, true);
}
} | 997 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandActionPlay.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/action/SubCommandActionPlay.java | package mchorse.blockbuster.commands.action;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.commands.CommandAction;
import mchorse.blockbuster.common.entity.EntityActor;
import mchorse.blockbuster.recording.data.Mode;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.World;
/**
* Sub-command /action play
*
* This sub-command is responsible for starting playback of ghost actor from
* given attributes.
*/
public class SubCommandActionPlay extends BBCommandBase
{
@Override
public String getName()
{
return "play";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.action.play";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}action {8}play{r} {7}<filename> [invincibility] [morph_nbt]{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
World world = sender.getEntityWorld();
EntityActor actor = CommandAction.actorFromArgs(args, world);
CommonProxy.manager.play(args[0], actor, Mode.BOTH, true);
world.spawnEntity(actor);
}
} | 1,452 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordReverse.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordReverse.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record reverse
*
* This command is responsible for reversing all frames and actions in
* the player recording
*/
public class SubCommandRecordReverse extends SubCommandRecordBase
{
@Override
public String getName()
{
return "reverse";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.reverse";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}reverse{r} {7}<filename>{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Record record = CommandRecord.getRecord(filename);
record.reverse();
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.reversed", filename);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", filename);
}
}
} | 1,487 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordCreate.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordCreate.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.Vec3d;
/**
* Command /record create
*
* This command is responsible for generating an empty player recording based on
* current player's position or arbitrary position and rotation
*/
public class SubCommandRecordCreate extends SubCommandRecordBase
{
@Override
public String getName()
{
return "create";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.create";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}create{r} {7}<filename> <duration> [x] [y] [z] [yaw] [pitch]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
try
{
Vec3d pos = sender.getPositionVector();
EntityPlayer player = sender instanceof EntityPlayer ? (EntityPlayer) sender : null;
int duration = CommandBase.parseInt(args[1], 1, 100000);
float yaw = player == null ? 0 : player.rotationYaw;
float pitch = player == null ? 0 : player.rotationPitch;
double x = args.length >= 3 ? CommandBase.parseDouble(pos.x, args[2], false) : pos.x;
double y = args.length >= 4 ? CommandBase.parseDouble(pos.y, args[3], false) : pos.y;
double z = args.length >= 5 ? CommandBase.parseDouble(pos.z, args[4], false) : pos.z;
yaw = args.length >= 6 ? (float) CommandBase.parseDouble(yaw, args[5], false) : yaw;
pitch = args.length >= 7 ? (float) CommandBase.parseDouble(pitch, args[6], false) : pitch;
Record record = this.generateProfile(player, filename, duration, x, y, z, yaw, pitch);
CommonProxy.manager.records.put(filename, record);
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.create", filename, duration);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", filename);
}
}
private Record generateProfile(EntityPlayer player, String filename, int duration, double x, double y, double z, float yaw, float pitch)
{
Record record = new Record(filename);
Frame original = new Frame();
if (player != null)
{
original.fromPlayer(player);
}
original.x = x;
original.y = y;
original.z = z;
original.yaw = original.yawHead = original.bodyYaw = yaw;
original.pitch = pitch;
original.hasBodyYaw = true;
for (int i = 0; i <= duration; i++)
{
record.frames.add(original.copy());
record.actions.add(null);
}
return record;
}
} | 3,458 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordRestore.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordRestore.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.io.File;
import java.util.List;
public class SubCommandRecordRestore extends SubCommandRecordBase
{
@Override
public String getName()
{
return "restore";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.restore";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}restore{r} {7}<filename> <iteration>{r}";
}
@Override
public int getRequiredArgs() {
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String name = args[0];
String iteration = args[1];
Record record = CommandRecord.getRecord(name);
if (RecordUtils.getReplayIterations(record.filename).contains(iteration))
{
File current = RecordUtils.replayFile(name);
File toRestore = new File(RecordUtils.replayFile(name).getAbsolutePath() + "~" + iteration);
File temporary = RecordUtils.replayFile("mchorse is the coolest");
if (temporary.exists())
{
Blockbuster.l10n.error(sender, "record.cant_restore", name);
}
else
{
current.renameTo(temporary);
toRestore.renameTo(current);
temporary.renameTo(toRestore);
CommonProxy.manager.records.remove(record.filename);
RecordUtils.unloadRecord(record);
Blockbuster.l10n.success(sender, "record.restored", name, iteration);
}
}
else
{
Blockbuster.l10n.error(sender, "record.not_exist_iteration", name, iteration);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos) {
if (args.length == 2)
{
List<String> iterations = RecordUtils.getReplayIterations(args[0]);
if (!iterations.isEmpty())
{
return getListOfStringsMatchingLastWord(args, iterations);
}
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 2,737 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordRemoveBodyYaw.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordRemoveBodyYaw.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
public class SubCommandRecordRemoveBodyYaw extends SubCommandRecordBase
{
@Override
public String getName()
{
return "remove_body_yaw";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.remove_body_yaw";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}remove_body_yaw{r} {7}<filename>{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Record record = CommandRecord.getRecord(filename);
for (int i = 0, c = record.frames.size(); i < c; i++)
{
Frame frame = record.frames.get(i);
frame.hasBodyYaw = false;
frame.bodyYaw = 0F;
}
RecordUtils.dirtyRecord(record);
Blockbuster.l10n.success(sender, "record.remove_body_yaw", filename);
}
}
| 1,419 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordSearch.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordSearch.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.ActionRegistry;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
public class SubCommandRecordSearch extends SubCommandRecordBase
{
@Override
public String getName()
{
return "search";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.search";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}search{r} {7}<filename> <action_type> [limit] [output_tags]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
if (!ActionRegistry.NAME_TO_CLASS.containsKey(args[1]))
{
throw new CommandException("record.wrong_action", args[1]);
}
String filename = args[0];
byte type = ActionRegistry.NAME_TO_ID.get(args[1]).byteValue();
Record record = CommandRecord.getRecord(filename);
int i = 0;
int tick = -1;
int limit = record.actions.size() + 1;
boolean outputData = args.length >= 4 ? CommandBase.parseBoolean(args[3]) : false;
if (args.length >= 3)
{
int temp = CommandBase.parseInt(args[2], -1);
if (temp >= 0)
{
limit = temp;
}
}
Blockbuster.l10n.info(sender, "record.search_type", args[1]);
for (List<Action> actions : record.actions)
{
tick++;
if (actions == null)
{
continue;
}
if (i >= limit)
{
break;
}
int j = -1;
for (Action action : actions)
{
j++;
if (ActionRegistry.getType(action) != type)
{
continue;
}
if (outputData)
{
NBTTagCompound tag = new NBTTagCompound();
action.toNBT(tag);
Blockbuster.l10n.info(sender, "record.search_action_data", tick, j, tag.toString());
}
else
{
Blockbuster.l10n.info(sender, "record.search_action", tick, j);
}
}
i++;
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 2)
{
return getListOfStringsMatchingLastWord(args, ActionRegistry.NAME_TO_CLASS.keySet());
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 3,318 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordRemoveAll.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordRemoveAll.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.client.gui.utils.keys.IKey;
import mchorse.mclib.network.mclib.Dispatcher;
import mchorse.mclib.network.mclib.client.ClientHandlerConfirm;
import mchorse.mclib.network.mclib.common.PacketConfirm;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import java.util.function.Consumer;
public class SubCommandRecordRemoveAll extends SubCommandRecordBase
{
@Override
public String getName()
{
return "remove_all";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.remove_all";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}remove_all{r} {7}<filename> [force]{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Record record = CommandRecord.getRecord(filename);
boolean force = (args.length > 1) ? CommandBase.parseBoolean(args[1]) : false;
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
this.dispatchConfirm(player, force, filename, (value) ->
{
if (value)
{
record.actions.replaceAll((actions) ->
{
return null;
});
}
});
}
private void dispatchConfirm(EntityPlayerMP player, boolean force, String filename, Consumer<Boolean> callback)
{
if (force)
{
callback.accept(force);
}
else
{
Dispatcher.sendTo(new PacketConfirm(ClientHandlerConfirm.GUI.MCSCREEN, IKey.format("blockbuster.commands.record.remove_all_modal", filename),(value) ->
{
callback.accept(value);
}), player);
}
}
}
| 2,269 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordOrigin.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordOrigin.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.Vec3d;
import java.util.List;
/**
* Command /record origin
*
* This command is responsible for changing the origin of player recordings.
*/
public class SubCommandRecordOrigin extends SubCommandRecordBase
{
@Override
public String getName()
{
return "origin";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.origin";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}origin{r} {7}<filename> [rotation] [x] [y] [z]{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Vec3d position = sender.getPositionVector();
Record record = CommandRecord.getRecord(filename);
double x = position.x;
double y = position.y;
double z = position.z;
double rotation = args.length >= 2 ? CommandBase.parseDouble(args[1]) : 0;
double firstX = 0;
double firstY = 0;
double firstZ = 0;
int i = 0;
for (Frame frame : record.frames)
{
if (i == 0)
{
firstX = frame.x;
firstY = frame.y;
firstZ = frame.z;
if (args.length >= 5)
{
x = CommandBase.parseDouble(firstX, args[2], false);
y = CommandBase.parseDouble(firstY, args[3], false);
z = CommandBase.parseDouble(firstZ, args[4], false);
}
}
double frameX = frame.x - firstX;
double frameY = frame.y - firstY;
double frameZ = frame.z - firstZ;
if (rotation != 0)
{
float cos = (float) Math.cos(rotation / 180 * Math.PI);
float sin = (float) Math.sin(rotation / 180 * Math.PI);
double xx = frameX * cos - frameZ * sin;
double zz = frameX * sin + frameZ * cos;
frameX = xx;
frameZ = zz;
frame.yaw += rotation;
frame.yawHead += rotation;
if (frame.hasBodyYaw)
{
frame.bodyYaw += rotation;
}
}
frame.x = x + frameX;
frame.y = y + frameY;
frame.z = z + frameZ;
i++;
}
for (List<Action> actions : record.actions)
{
if (actions == null || actions.isEmpty())
{
continue;
}
for (Action action : actions)
{
action.changeOrigin(rotation, x, y, z, firstX, firstY, firstZ);
}
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.changed_origin", args[0], firstX, firstY, firstZ, x, y, z);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 3,722 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordInfo.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordInfo.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record info
*
* This command is responsible for outputting information about given record.
*/
public class SubCommandRecordInfo extends SubCommandRecordBase
{
@Override
public String getName()
{
return "info";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.info";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}info{r} {7}<filename>{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Record record = CommandRecord.getRecord(filename);
Blockbuster.l10n.info(sender, "record.info", args[0], record.version, record.frames.size(), record.unload);
}
} | 1,184 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordProlong.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordProlong.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record prolong
*
* This command is responsible for duplicating player recording to a new
* player recording file
*/
public class SubCommandRecordProlong extends SubCommandRecordBase
{
@Override
public String getName()
{
return "prolong";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.prolong";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}prolong{r} {7}<filename> [post_delay] [pre_delay]{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record record = CommandRecord.getRecord(args[0]);
if (args.length >= 2)
{
record.postDelay = CommandBase.parseInt(args[1]);
}
if (args.length >= 3)
{
record.preDelay = CommandBase.parseInt(args[2]);
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.prolonged", args[0], record.preDelay, record.postDelay);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 1,755 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordCalculateBodyYaw.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordCalculateBodyYaw.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.SwipeAction;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.MathHelper;
import java.util.List;
public class SubCommandRecordCalculateBodyYaw extends SubCommandRecordBase
{
@Override
public String getName()
{
return "calculate_body_yaw";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.calculate_body_yaw";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}calculate_body_yaw{r} {7}<filename>{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
Record record = CommandRecord.getRecord(filename);
Frame prev = null;
float renderYawOffset = 0;
int swingProgress = 0;
for (int i = 0, c = record.frames.size(); i < c; i++)
{
Frame frame = record.frames.get(i);
List<Action> actions = record.getActions(i);
if (actions != null)
{
for (Action action : actions)
{
if (action instanceof SwipeAction)
{
swingProgress = 6;
}
}
}
if (prev == null)
{
prev = frame;
renderYawOffset = prev.yaw;
}
double dx = frame.x - prev.x;
double dz = frame.z - prev.z;
float distSq = (float)(dx * dx + dz * dz);
float tempRenderyawOffset = renderYawOffset;
if (distSq > 0.0025000002F)
{
float f1 = (float) MathHelper.atan2(dz, dx) * (180F / (float)Math.PI) - 90.0F;
float f2 = MathHelper.abs(MathHelper.wrapDegrees(frame.yaw) - f1);
if (95.0F < f2 && f2 < 265.0F)
{
tempRenderyawOffset = f1 - 180.0F;
}
else
{
tempRenderyawOffset = f1;
}
}
if (swingProgress > 0)
{
renderYawOffset = frame.yaw;
}
float coolBob = MathHelper.wrapDegrees(tempRenderyawOffset - renderYawOffset);
renderYawOffset += coolBob * 0.3F;
float anotherCoolBob = MathHelper.wrapDegrees(frame.yaw - renderYawOffset);
if (anotherCoolBob < -75.0F)
{
anotherCoolBob = -75.0F;
}
if (anotherCoolBob >= 75.0F)
{
anotherCoolBob = 75.0F;
}
renderYawOffset = frame.yaw - anotherCoolBob;
if (anotherCoolBob * anotherCoolBob > 2500.0F)
{
renderYawOffset += anotherCoolBob * 0.2F;
}
frame.hasBodyYaw = true;
frame.bodyYaw = renderYawOffset;
prev = frame;
swingProgress--;
}
RecordUtils.dirtyRecord(record);
Blockbuster.l10n.success(sender, "record.calculate_body_yaw", filename);
}
}
| 3,697 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordClean.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordClean.java | package mchorse.blockbuster.commands.record;
import com.google.common.collect.ImmutableSet;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
import java.util.Set;
/**
* Command /record clean
*
* This command is responsible for cleaning given property from player
* recording.
*/
public class SubCommandRecordClean extends SubCommandRecordBase
{
public static final Set<String> PROPERTIES = ImmutableSet.of("x", "y", "z", "yaw", "yaw_head", "body_yaw", "pitch", "fall_distance", "sprinting", "sneaking", "active_hands", "mounted", "roll");
public static double get(String property, Frame frame)
{
if (property.equals("x"))
{
return frame.x;
}
else if (property.equals("y"))
{
return frame.y;
}
else if (property.equals("z"))
{
return frame.z;
}
else if (property.equals("yaw"))
{
return frame.yaw;
}
else if (property.equals("yaw_head"))
{
return frame.yawHead;
}
else if (property.equals("body_yaw"))
{
return frame.bodyYaw;
}
else if (property.equals("pitch"))
{
return frame.pitch;
}
else if (property.equals("fall_distance"))
{
return frame.fallDistance;
}
else if (property.equals("sprinting"))
{
return frame.isSprinting ? 1 : 0;
}
else if (property.equals("sneaking"))
{
return frame.isSneaking ? 1 : 0;
}
else if (property.equals("active_hands"))
{
return frame.activeHands;
}
else if (property.equals("mounted"))
{
return frame.isMounted ? 1 : 0;
}
else if (property.equals("roll"))
{
return frame.roll;
}
return 0;
}
public static void set(String property, Frame frame, double value)
{
if (property.equals("x"))
{
frame.x = value;
}
else if (property.equals("y"))
{
frame.y = value;
}
else if (property.equals("z"))
{
frame.z = value;
}
else if (property.equals("yaw"))
{
frame.yaw = (float) value;
}
else if (property.equals("yaw_head"))
{
frame.yawHead = (float) value;
}
else if (property.equals("body_yaw"))
{
frame.hasBodyYaw = true;
frame.bodyYaw = (float) value;
}
else if (property.equals("pitch"))
{
frame.pitch = (float) value;
}
else if (property.equals("fall_distance"))
{
frame.fallDistance = (float) value;
}
else if (property.equals("sprinting"))
{
frame.isSprinting = value == 1;
}
else if (property.equals("sneaking"))
{
frame.isSneaking = value == 1;
}
else if (property.equals("active_hands"))
{
frame.activeHands = (int) value;
}
else if (property.equals("mounted"))
{
frame.isMounted = value == 1;
}
else if (property.equals("roll"))
{
frame.roll = (float) value;
}
}
@Override
public String getName()
{
return "clean";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.clean";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}clean{r} {7}<filename> <property> [value] [from] [to]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
String property = args[1];
Record record = CommandRecord.getRecord(filename);
if (!PROPERTIES.contains(property))
{
throw new CommandException("record.wrong_clean_property", property);
}
int start = 0;
int end = record.getLength() - 1;
if (args.length >= 4)
{
start = CommandBase.parseInt(args[3], start, end);
}
if (args.length >= 5)
{
end = CommandBase.parseInt(args[4], start, end);
}
double original = get(property, record.frames.get(start));
if (args.length >= 3)
{
original = CommandBase.parseDouble(original, args[2], false);
}
for (int i = start; i <= end; i++)
{
set(property, record.frames.get(i), original);
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.clean", filename, property, start, end);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 2)
{
return getListOfStringsMatchingLastWord(args, PROPERTIES);
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 5,957 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordMerge.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordMerge.java | package mchorse.blockbuster.commands.record;
import java.util.ArrayList;
import java.util.List;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.MorphAction;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record merge
*
* This command is responsible for merging the actions in the
* source record into the destination record.
*/
public class SubCommandRecordMerge extends SubCommandRecordBase
{
@Override
public String getName()
{
return "merge";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.merge";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}merge{r} {7}<source> <destination> [morph_only]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record src = CommandRecord.getRecord(args[0]);
Record dst = CommandRecord.getRecord(args[1]);
boolean morph = false;
if (args.length > 2)
{
morph = CommandBase.parseBoolean(args[2]);
}
int size = Math.min(src.actions.size(), dst.actions.size());
for (int i = 0; i < size; i++)
{
if (i >= dst.actions.size())
{
break;
}
List<Action> srcActions = src.actions.get(i);
List<Action> dstActions = dst.actions.get(i);
if (srcActions != null)
{
for (Action action : srcActions)
{
if (!morph || action instanceof MorphAction)
{
if (dstActions == null)
{
dstActions = new ArrayList<Action>();
dst.actions.set(i, dstActions);
}
dstActions.add(action);
}
}
}
}
try
{
RecordUtils.saveRecord(dst);
Blockbuster.l10n.success(sender, "record.merge", args[0], args[1]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
}
| 2,800 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordFade.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordFade.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.utils.Interpolations;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record fade
*
* This command is responsible for fading out the player recording to
* the first frame.
*/
public class SubCommandRecordFade extends SubCommandRecordBase
{
@Override
public String getName()
{
return "fade";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.fade";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}fade{r} {7}<filename> <fade_out>{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record record = CommandRecord.getRecord(args[0]);
int length = record.getLength();
int fadeOut = CommandBase.parseInt(args[1], 1, length);
if (length == 0)
{
Blockbuster.l10n.error(sender, "record.empty", record.filename);
return;
}
/* Process */
Frame first = record.getFrame(0);
Frame last = record.getFrame(length - fadeOut - 1);
for (int i = 0; i < fadeOut; i ++)
{
Frame current = record.getFrame(length - fadeOut + i);
float x = i / (float) fadeOut;
current.x = Interpolations.lerp(last.x, first.x, x);
current.y = Interpolations.lerp(last.y, first.y, x);
current.z = Interpolations.lerp(last.z, first.z, x);
current.yaw = Interpolations.lerpYaw(last.yaw, first.yaw, x);
current.yawHead = Interpolations.lerpYaw(last.yawHead, first.yawHead, x);
current.mountYaw = Interpolations.lerp(last.mountYaw, first.mountYaw, x);
current.pitch = Interpolations.lerp(last.pitch, first.pitch, x);
current.mountPitch = Interpolations.lerp(last.mountPitch, first.mountPitch, x);
if (current.hasBodyYaw && first.hasBodyYaw)
{
current.bodyYaw = Interpolations.lerpYaw(last.bodyYaw, first.bodyYaw, x);
}
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.faded", args[0], args[1]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
}
| 2,966 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordErase.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordErase.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.utils.MathUtils;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import java.util.ArrayList;
import java.util.List;
public class SubCommandRecordErase extends SubCommandRecordBase
{
@Override
public String getName()
{
return "erase";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.erase";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}erase{r} {7}<filename> <count> <from>{r}";
}
@Override
public int getRequiredArgs()
{
return 3;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record record = CommandRecord.getRecord(args[0]);
int count = CommandBase.parseInt(args[1], 0);
int from = CommandBase.parseInt(args[2], 0, record.getLength() - 1);
count = MathUtils.clamp(count, 0, record.getLength() - 1 - from);
if (record.getLength() == 0)
{
Blockbuster.l10n.error(sender, "record.empty", record.filename);
return;
}
/* Process */
List<Frame> frames = new ArrayList<Frame>();
List<List<Action>> actions = new ArrayList<List<Action>>();
frames.addAll(record.frames);
actions.addAll(record.actions);
for (int i = 0; i < count; i++)
{
frames.remove(from);
actions.remove(from);
}
record.frames = frames;
record.actions = actions;
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.erase", count, from, args[0], record.getLength());
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 2,418 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordRename.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordRename.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
public class SubCommandRecordRename extends SubCommandRecordBase
{
@Override
public String getName()
{
return "rename";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.rename";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}rename{r} {7}<filename> <new_filename>{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
if (RecordUtils.isReplayExists(args[1]))
{
throw new CommandException("record.already_exists", args[1]);
}
try
{
Record record = CommandRecord.getRecord(args[0]).clone();
record.filename = args[1];
record.save(RecordUtils.replayFile(record.filename));
CommonProxy.manager.rename(args[0], record);
Blockbuster.l10n.success(sender, "record.renamed", args[0], args[1]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 1,701 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordDupe.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordDupe.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
/**
* Command /record dupe
*
* This command is responsible for duplicating player recording to a new
* player recording file
*/
public class SubCommandRecordDupe extends SubCommandRecordBase
{
@Override
public String getName()
{
return "dupe";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.dupe";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}dupe{r} {7}<filename> <new_filename> [overwrite]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
boolean overwrite = (args.length>2) ? CommandBase.parseBoolean(args[2]) : false;
if (RecordUtils.isReplayExists(args[1]) && !overwrite)
{
throw new CommandException("record.already_exists", args[1]);
}
try
{
Record record = CommandRecord.getRecord(args[0]).clone();
record.filename = args[1];
record.save(RecordUtils.replayFile(record.filename));
CommonProxy.manager.records.put(args[1], record);
Blockbuster.l10n.success(sender, "record.duped", args[0], args[1]);
}
catch (Exception e)
{
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 1,955 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordTP.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordTP.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
/**
* Command /record tp
*
* This command is responsible for teleporting the player to the given
* frame at tick in given player recording.
*/
public class SubCommandRecordTP extends SubCommandRecordBase
{
@Override
public String getName()
{
return "tp";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.tp";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}tp{r} {7}<filename> [tick]{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
int tick = args.length > 1 ? CommandBase.parseInt(args[1]) : 0;
Record record = CommandRecord.getRecord(filename);
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
RecordUtils.applyFrameOnEntity(player, record, tick);
}
} | 1,407 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordBase.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordBase.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.recording.RecordUtils;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
public abstract class SubCommandRecordBase extends BBCommandBase
{
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, RecordUtils.getReplays());
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 796 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordFill.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordFill.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import java.util.ArrayList;
import java.util.List;
public class SubCommandRecordFill extends SubCommandRecordBase
{
@Override
public String getName()
{
return "fill";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.fill";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}fill{r} {7}<filename> <count> [tick]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
int count = CommandBase.parseInt(args[1], 1);
Record record = CommandRecord.getRecord(filename);
int tick = record.frames.size() - 1;
boolean add = true;
if (args.length > 2)
{
tick = CommandBase.parseInt(args[2], 0, tick);
add = false;
}
Frame original = record.getFrame(tick).copy();
List<Frame> frames = record.frames;
List<List<Action>> actions = record.actions;
if (!add)
{
frames = new ArrayList<Frame>();
actions = new ArrayList<List<Action>>();
for (int i = 0; i <= tick; i ++)
{
frames.add(record.getFrame(i));
actions.add(record.getActions(i));
}
}
for (int i = 0; i < count; i ++)
{
frames.add(original.copy());
actions.add(null);
}
if (!add)
{
for (int i = tick + 1; i < record.frames.size(); i ++)
{
frames.add(record.getFrame(i));
actions.add(record.getActions(i));
}
record.frames = frames;
record.actions = actions;
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.fill", count, tick, filename, record.frames.size());
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
}
| 2,803 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordProcess.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordProcess.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.math.IValue;
import mchorse.mclib.math.MathBuilder;
import mchorse.mclib.math.Variable;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
/**
* Command /record process
*
* This command is responsible for processing given property according to given
* math expression
*/
public class SubCommandRecordProcess extends SubCommandRecordBase
{
public MathBuilder builder;
public Variable initial;
public Variable value;
public Variable tick;
public Variable from;
public Variable to;
public Variable factor;
public SubCommandRecordProcess()
{
this.builder = new MathBuilder();
this.builder.register(this.initial = new Variable("initial", 0));
this.builder.register(this.value = new Variable("value", 0));
this.builder.register(this.tick = new Variable("tick", 0));
this.builder.register(this.from = new Variable("from", 0));
this.builder.register(this.to = new Variable("to", 0));
this.builder.register(this.factor = new Variable("factor", 0));
}
@Override
public String getName()
{
return "process";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.process";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}process{r} {7}<filename> <property> <from> <to> <math>{r}";
}
@Override
public int getRequiredArgs()
{
return 5;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
String property = args[1];
Record record = CommandRecord.getRecord(filename);
if (!SubCommandRecordClean.PROPERTIES.contains(property))
{
throw new CommandException("record.wrong_clean_property", property);
}
int start = 0;
int end = record.getLength() - 1;
start = CommandBase.parseInt(args[2], start, end);
end = CommandBase.parseInt(args[3], start, end);
double initial = SubCommandRecordClean.get(property, record.frames.get(start));
String expression = String.join(" ", SubCommandBase.dropFirstArguments(args, 4));
IValue math;
try
{
math = this.builder.parse(expression);
}
catch (Exception e)
{
throw new CommandException("record.invalid_math_expression", expression);
}
this.from.set(start);
this.to.set(end);
for (int i = start; i <= end; i++)
{
Frame frame = record.frames.get(i);
this.initial.set(initial);
this.value.set(SubCommandRecordClean.get(property, frame));
this.tick.set(i);
this.factor.set((i - start) / (double) (end - start));
SubCommandRecordClean.set(property, frame, math.get().doubleValue());
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.process", filename, property, start, end);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 2)
{
return getListOfStringsMatchingLastWord(args, SubCommandRecordClean.PROPERTIES);
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 4,222 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordCut.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordCut.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import java.util.ArrayList;
import java.util.List;
public class SubCommandRecordCut extends SubCommandRecordBase
{
@Override
public String getName()
{
return "cut";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.cut";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}cut{r} {7}<filename> <before> <after>{r}";
}
@Override
public int getRequiredArgs()
{
return 3;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record record = CommandRecord.getRecord(args[0]);
int from = CommandBase.parseInt(args[1], 0, record.getLength() - 1);
int to = CommandBase.parseInt(args[2], 0, record.getLength() - 1);
int min = Math.min(from, to);
to = Math.max(from, to);
from = min;
if (record.getLength() == 0)
{
Blockbuster.l10n.error(sender, "record.empty", record.filename);
return;
}
/* Process */
List<Frame> frames = new ArrayList<Frame>();
List<List<Action>> actions = new ArrayList<List<Action>>();
frames.addAll(record.frames.subList(from, to));
actions.addAll(record.actions.subList(from, to));
record.frames = frames;
record.actions = actions;
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.cut", args[0], args[1], args[2]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
} | 2,303 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordDelete.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordDelete.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.mclib.client.gui.framework.elements.GuiConfirmationScreen;
import mchorse.mclib.client.gui.utils.keys.IKey;
import mchorse.mclib.network.mclib.Dispatcher;
import mchorse.mclib.network.mclib.client.ClientHandlerConfirm;
import mchorse.mclib.network.mclib.common.PacketConfirm;
import mchorse.mclib.utils.OpHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
/**
* Command /record delete
*
* This command is responsible for deleting a recording.
*/
public class SubCommandRecordDelete extends SubCommandRecordBase
{
@Override
public String getName()
{
return "delete";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.delete";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}delete{r} {7}<filename> [force]{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
if (!OpHelper.isPlayerOp(player))
{
throw new CommandException("record.delete_rights");
}
String filename = args[0];
//throws exception if recording doesn't exist
CommandRecord.getRecord(filename);
boolean force = (args.length>1) ? CommandBase.parseBoolean(args[1]) : false;
if (force)
{
this.deleteRecording(filename);
}
else
{
Dispatcher.sendTo(new PacketConfirm(ClientHandlerConfirm.GUI.MCSCREEN, IKey.format("blockbuster.commands.record.delete_modal", filename),
(value) ->
{
if(value)
{
this.deleteRecording(filename);
}
}), player);
}
}
private void deleteRecording(String filename)
{
try
{
RecordUtils.replayFile(filename).delete();
RecordUtils.unloadRecord(CommonProxy.manager.records.get(filename));
CommonProxy.manager.records.remove(filename);
}
catch (NullPointerException e)
{}
}
}
| 2,858 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordAdd.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordAdd.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.ActionRegistry;
import mchorse.blockbuster.recording.data.Record;
import mchorse.metamorph.commands.CommandMorph;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.nbt.JsonToNBT;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.List;
/**
* Command /record add
*
* This command is responsible for adding a desired action to the given player
* recording.
*/
public class SubCommandRecordAdd extends SubCommandRecordBase
{
@Override
public String getName()
{
return "add";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.add";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}add{r} {7}<filename> <tick> <action_type> [data_tag]{r}";
}
@Override
public int getRequiredArgs()
{
return 3;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
int tick = CommandBase.parseInt(args[1], 0);
Record record = CommandRecord.getRecord(filename);
if (tick < 0 || tick >= record.actions.size())
{
throw new CommandException("record.tick_out_range", tick, record.actions.size() - 1);
}
if (!ActionRegistry.NAME_TO_CLASS.containsKey(args[2]))
{
throw new CommandException("record.wrong_action", args[2]);
}
try
{
Action action = ActionRegistry.fromName(args[2]);
if (args.length > 3)
{
action.fromNBT(JsonToNBT.getTagFromJson(CommandMorph.mergeArgs(args, 3)));
}
record.addAction(tick, action);
record.dirty = true;
}
catch (Exception e)
{
throw new CommandException("record.add", args[2], e.getMessage());
}
}
/**
* Tab complete action
*/
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 3)
{
return getListOfStringsMatchingLastWord(args, ActionRegistry.NAME_TO_ID.keySet());
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 2,690 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordGet.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordGet.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.actions.ActionRegistry;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import java.util.List;
/**
* Command /record get
*
* This command is responsible for outputting data of action at given tick and
* player recording.
*/
public class SubCommandRecordGet extends SubCommandRecordBase
{
@Override
public String getName()
{
return "get";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.get";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}get{r} {7}<filename> <tick>{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
int tick = CommandBase.parseInt(args[1], 0);
Record record = CommandRecord.getRecord(filename);
if (tick <= 0 || tick >= record.actions.size())
{
throw new CommandException("record.tick_out_range", tick, record.actions.size() - 1);
}
List<Action> actions = record.actions.get(tick);
if (actions == null)
{
throw new CommandException("record.no_action", filename, tick);
}
for (int i = 0, c = actions.size(); i < c; i++)
{
Action action = actions.get(i);
NBTTagCompound tag = new NBTTagCompound();
String type = ActionRegistry.NAME_TO_CLASS.inverse().get(action.getClass());
action.toNBT(tag);
Blockbuster.l10n.info(sender, "record.action", tick, type, i, tag.toString());
}
}
} | 2,190 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordFlip.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordFlip.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Vec3d;
import java.util.Arrays;
import java.util.List;
public class SubCommandRecordFlip extends SubCommandRecordBase
{
public static List<String> ALLOWED_AXES = Arrays.asList("x", "z");
@Override
public String getName()
{
return "flip";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.flip";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}flip{r} {7}<filename> <axis:X|Z> <coordinate> [center]{r}";
}
@Override
public int getRequiredArgs()
{
return 3;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
Record record = CommandRecord.getRecord(args[0]);
String axis = args[1].toLowerCase();
boolean center = args.length < 4 ? true : CommandBase.parseBoolean(args[3]);
double coordinate = CommandBase.parseInt(args[2]) + (center ? 0.5 : 0);
if (!ALLOWED_AXES.contains(axis))
{
Blockbuster.l10n.error(sender, "record.wrong_axis", args[1]);
return;
}
for (Frame frame : record.frames)
{
if (axis.equals("x"))
{
double diff = coordinate - frame.x;
frame.x = coordinate + diff;
frame.yaw *= -1;
frame.yawHead *= -1;
frame.mountYaw *= -1;
}
else
{
double diff = coordinate - frame.z;
frame.z = coordinate + diff;
frame.yaw = -frame.yaw + 180;
frame.yawHead = -frame.yawHead + 180;
frame.mountYaw = -frame.mountYaw + 180;
}
}
for (List<Action> actions : record.actions)
{
if (actions == null)
{
continue;
}
for (Action action : actions)
{
action.flip(axis, center ? Math.floor(coordinate) : coordinate - 0.5);
}
}
try
{
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.flipped", args[0], args[1], args[2]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 2)
{
return getListOfStringsMatchingLastWord(args, ALLOWED_AXES);
}
else if (args.length == 3 && ALLOWED_AXES.contains(args[1]))
{
Vec3d vec3d = sender.getPositionVector();
int coordinate = (int) Math.floor(args[1].equals("x") ? vec3d.x : vec3d.z);
return getListOfStringsMatchingLastWord(args, Arrays.asList(coordinate));
}
else if (args.length == 4)
{
return getListOfStringsMatchingLastWord(args, new String[] {"true", "false"});
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 3,865 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordRemove.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordRemove.java | package mchorse.blockbuster.commands.record;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.actions.Action;
import mchorse.blockbuster.recording.data.Record;
import mchorse.mclib.client.gui.framework.elements.GuiConfirmationScreen;
import mchorse.mclib.client.gui.utils.keys.IKey;
import mchorse.mclib.network.mclib.Dispatcher;
import mchorse.mclib.network.mclib.client.ClientHandlerConfirm;
import mchorse.mclib.network.mclib.common.PacketConfirm;
import mchorse.mclib.utils.OpHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import java.util.List;
import java.util.function.Consumer;
/**
* Command /record remove
*
* This command is responsible for removing action(s) from given player
* recording.
*/
public class SubCommandRecordRemove extends SubCommandRecordBase
{
@Override
public String getName()
{
return "remove";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.remove";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}remove{r} {7}<filename> <tick> [index] [force]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
int tick = CommandBase.parseInt(args[1], 0);
Record record = CommandRecord.getRecord(filename);
if (tick < 0 || tick >= record.actions.size())
{
throw new CommandException("record.tick_out_range", tick, record.actions.size() - 1);
}
this.removeActions(args, sender, record, tick);
}
/**
* Remove action(s) from given record at given tick
*/
private void removeActions(String[] args, ICommandSender sender, Record record, int tick) throws CommandException
{
EntityPlayerMP player = getCommandSenderAsPlayer(sender);
boolean force = (args.length>3) ? CommandBase.parseBoolean(args[3]) : false;
//index of -1 means to remove all actions
if (args.length > 2 && CommandBase.parseInt(args[2]) != -1)
{
int index = CommandBase.parseInt(args[2]);
List<Action> actions = record.actions.get(tick);
if (actions == null)
{
throw new CommandException("record.already_empty", args[1], args[0]);
}
if (index < -1 || index >= actions.size())
{
throw new CommandException("record.index_out_range", index, actions.size() - 1);
}
dispatchConfirm(player, force, (value) ->
{
if (value)
{
/* Remove action at given tick */
if (actions.size() <= 1)
{
record.actions.set(tick, null);
}
else
{
actions.remove(index);
}
}
});
}
else
{
dispatchConfirm(player, force, (value) ->
{
if (value)
{
/* Remove all actions at tick */
record.actions.set(tick, null);
}
});
}
record.dirty = true;
}
private void dispatchConfirm(EntityPlayerMP player, boolean force, Consumer<Boolean> callback)
{
if (force)
{
callback.accept(force);
}
else
{
Dispatcher.sendTo(new PacketConfirm(ClientHandlerConfirm.GUI.MCSCREEN, IKey.lang("blockbuster.commands.record.remove_modal"),(value) ->
{
callback.accept(value);
}), player);
}
}
} | 4,355 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordApply.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordApply.java | package mchorse.blockbuster.commands.record;
import com.google.common.collect.ImmutableList;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.commands.CommandRecord;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* Command /record apply
*
* This command is responsible for applying one player recording to another
* player recording file
*/
public class SubCommandRecordApply extends SubCommandRecordBase
{
@Override
public String getName()
{
return "apply";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.apply";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}apply{r} {7}<target> <source> <properties> [relative] [from] [to]{r}";
}
@Override
public int getRequiredArgs()
{
return 3;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String target = args[0];
String source = args[1];
List<String> properties = new ArrayList<String>();
if (args[2].contains(","))
{
properties.addAll(Arrays.asList(args[2].split(",")));
}
else
{
properties.add(args[2]);
}
Record targetRecord = CommandRecord.getRecord(target);
Record sourceRecord = CommandRecord.getRecord(source);
List<String> newProperties = new ArrayList<String>();
for (String property : properties)
{
if (property.equalsIgnoreCase("head"))
{
newProperties.addAll(ImmutableList.of("yaw", "yaw_head", "pitch"));
}
else if (property.equalsIgnoreCase("position"))
{
newProperties.addAll(ImmutableList.of("x", "y", "z"));
}
else if (SubCommandRecordClean.PROPERTIES.contains(property))
{
newProperties.add(property);
}
}
if (newProperties.isEmpty())
{
throw new CommandException("record.wrong_apply_property", String.join(", ", properties));
}
int start = 0;
int end = Math.min(targetRecord.frames.size() - 1, sourceRecord.frames.size() - 1);
boolean relative = args.length >= 4 && CommandBase.parseBoolean(args[3]);
if (args.length >= 5)
{
start = CommandBase.parseInt(args[4], start, end);
}
if (args.length >= 6)
{
end = CommandBase.parseInt(args[5], start, end);
}
for (String property : newProperties)
{
this.apply(property, targetRecord, sourceRecord, relative, start, end);
}
try
{
RecordUtils.saveRecord(targetRecord);
Blockbuster.l10n.success(sender, "record.apply", target, String.join(", ", newProperties), source, start, end);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", args[1]);
}
}
private void apply(String property, Record targetRecord, Record sourceRecord, boolean relative, int start, int end)
{
double firstOriginal = SubCommandRecordClean.get(property, sourceRecord.frames.get(start));
for (int i = start; i <= end; i++)
{
double original = SubCommandRecordClean.get(property, sourceRecord.frames.get(i));
double value = SubCommandRecordClean.get(property, targetRecord.frames.get(i));
SubCommandRecordClean.set(property, targetRecord.frames.get(i), relative ? value + (original - firstOriginal) : original);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 3)
{
List<String> props = new ArrayList<>(SubCommandRecordClean.PROPERTIES);
props.add("head");
props.add("position");
return getListOfStringsMatchingLastWord(args, props);
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 4,649 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandRecordCamera.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/record/SubCommandRecordCamera.java | package mchorse.blockbuster.commands.record;
import mchorse.aperture.Aperture;
import mchorse.aperture.camera.CameraAPI;
import mchorse.aperture.camera.CameraProfile;
import mchorse.aperture.camera.CameraUtils;
import mchorse.aperture.camera.data.Position;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.aperture.CameraHandler;
import mchorse.blockbuster.recording.RecordUtils;
import mchorse.blockbuster.recording.data.Frame;
import mchorse.blockbuster.recording.data.Record;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.common.Optional;
import java.util.List;
/**
* Command /record camera
*
* This command is responsible for generating a player recording based on
* an Aperture camera profile (works only if Aperture installed)
*/
public class SubCommandRecordCamera extends SubCommandRecordBase
{
@Override
public String getName()
{
return "camera";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.record.camera";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}record {8}camera{r} {7}<filename> <camera_profile> [x] [y] [z]{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String filename = args[0];
try
{
float x = args.length >= 3 ? (float) CommandBase.parseDouble(args[2]) : 0;
float y = args.length >= 4 ? (float) CommandBase.parseDouble(args[3]) : 0;
float z = args.length >= 5 ? (float) CommandBase.parseDouble(args[4]) : 0;
Record record = this.generate(filename, args[1], x, y, z);
CommonProxy.manager.records.put(filename, record);
RecordUtils.saveRecord(record);
Blockbuster.l10n.success(sender, "record.camera", filename, args[1]);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "record.couldnt_save", filename);
}
}
private Record generate(String filename, String profile, float x, float y, float z) throws Exception
{
if (CameraHandler.isApertureLoaded())
{
return this.generateProfile(filename, profile, x, y, z);
}
throw new IllegalStateException("/record camera can't be used, because Aperture mod isn't installed!");
}
@Optional.Method(modid = Aperture.MOD_ID)
private Record generateProfile(String filename, String profile, float x, float y, float z) throws Exception
{
Record record = new Record(filename);
CameraProfile camera = CameraUtils.readProfile(profile);
Position prev = new Position();
Position position = new Position();
int c = (int) camera.getDuration();
for (int i = 0; i <= c; i++)
{
Frame frame = new Frame();
if (i == c)
{
camera.applyProfile(c - 1, 0.999F, position);
}
else
{
camera.applyProfile(i, 0, position);
}
if (i == 0)
{
prev.copy(position);
}
frame.x = position.point.x + x;
frame.y = position.point.y + y;
frame.z = position.point.z + z;
frame.yaw = position.angle.yaw;
frame.yawHead = position.angle.yaw;
frame.bodyYaw = position.angle.yaw;
frame.pitch = position.angle.pitch;
frame.roll = position.angle.roll;
frame.motionX = position.point.x - prev.point.x;
frame.motionY = position.point.y - prev.point.y;
frame.motionZ = position.point.z - prev.point.z;
frame.hasBodyYaw = true;
record.frames.add(frame);
record.actions.add(null);
prev.copy(position);
}
return record;
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 2 && CameraHandler.isApertureLoaded())
{
return getListOfStringsMatchingLastWord(args, getCameraProfiles());
}
return super.getTabCompletions(server, sender, args, pos);
}
@Optional.Method(modid = Aperture.MOD_ID)
private List<String> getCameraProfiles()
{
return CameraAPI.getServerProfiles();
}
} | 4,836 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelBlockMorph.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/modelblock/SubCommandModelBlockMorph.java | package mchorse.blockbuster.commands.modelblock;
import mchorse.blockbuster.common.tileentity.TileEntityModel;
import mchorse.blockbuster.network.Dispatcher;
import mchorse.blockbuster.network.common.PacketModifyModelBlock;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.metamorph.api.MorphManager;
import mchorse.metamorph.api.morphs.AbstractMorph;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.nbt.JsonToNBT;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.fml.common.network.NetworkRegistry;
public class SubCommandModelBlockMorph extends SubCommandModelBlockBase
{
@Override
public String getName()
{
return "morph";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.modelblock.morph";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}modelblock {8}morph{r} {7}<x> <y> <z> [morph_nbt]{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
TileEntityModel model = this.getModelBlock(sender, args);
String morphData = args.length >= 4 ? String.join(" ", SubCommandBase.dropFirstArguments(args, 3)) : null;
AbstractMorph morph = null;
if (morphData != null)
{
try
{
morph = MorphManager.INSTANCE.morphFromNBT(JsonToNBT.getTagFromJson(morphData));
}
catch (Exception e)
{}
}
model.setMorph(morph);
int x = model.getPos().getX();
int y = model.getPos().getY();
int z = model.getPos().getZ();
PacketModifyModelBlock message = new PacketModifyModelBlock(model.getPos(), model, true);
Dispatcher.DISPATCHER.get().sendToAllAround(message, new NetworkRegistry.TargetPoint(sender.getEntityWorld().provider.getDimension(), x, y, z, 64));
}
} | 2,032 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelBlockProperty.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/modelblock/SubCommandModelBlockProperty.java | package mchorse.blockbuster.commands.modelblock;
import com.google.common.collect.ImmutableList;
import mchorse.blockbuster.common.tileentity.TileEntityModel;
import mchorse.blockbuster.network.Dispatcher;
import mchorse.blockbuster.network.common.PacketModifyModelBlock;
import mchorse.mclib.commands.McCommandBase;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import net.minecraftforge.fml.common.network.NetworkRegistry;
import javax.annotation.Nullable;
import java.util.List;
public class SubCommandModelBlockProperty extends SubCommandModelBlockBase
{
public static final List<String> PROPERTIES = ImmutableList.of("enabled");
@Override
public String getName()
{
return "property";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.modelblock.property";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}modelblock {8}property{r} {7}<x> <y> <z> <property:enabled> <value>{r}";
}
@Override
public int getRequiredArgs()
{
return 5;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
TileEntityModel model = this.getModelBlock(sender, args);
String property = args[3];
if (!PROPERTIES.contains(property))
{
throw new CommandException("modelblock.wrong_property", property);
}
if (property.equals("enabled"))
{
model.getSettings().setEnabled(CommandBase.parseBoolean(args[4]));
}
model.markDirty();
int x = model.getPos().getX();
int y = model.getPos().getY();
int z = model.getPos().getZ();
PacketModifyModelBlock message = new PacketModifyModelBlock(model.getPos(), model);
Dispatcher.DISPATCHER.get().sendToAllAround(message, new NetworkRegistry.TargetPoint(sender.getEntityWorld().provider.getDimension(), x, y, z, 64));
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, @Nullable BlockPos targetPos)
{
if (args.length == 4)
{
return getListOfStringsMatchingLastWord(args, PROPERTIES);
}
else if (args.length == 5)
{
String property = args[3];
if (property.equals("enabled"))
{
return getListOfStringsMatchingLastWord(args, McCommandBase.BOOLEANS);
}
}
return super.getTabCompletions(server, sender, args, targetPos);
}
} | 2,803 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelBlockBase.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/modelblock/SubCommandModelBlockBase.java | package mchorse.blockbuster.commands.modelblock;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.blockbuster.common.tileentity.TileEntityModel;
import net.minecraft.command.CommandBase;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.math.BlockPos;
public abstract class SubCommandModelBlockBase extends BBCommandBase
{
@Override
public int getRequiredArgs()
{
return 3;
}
public TileEntityModel getModelBlock(ICommandSender sender, String[] args) throws CommandException
{
int x = CommandBase.parseInt(args[0]);
int y = CommandBase.parseInt(args[1]);
int z = CommandBase.parseInt(args[2]);
TileEntity tile = sender.getEntityWorld().getTileEntity(new BlockPos(x, y, z));
if (tile instanceof TileEntityModel)
{
return (TileEntityModel) tile;
}
throw new CommandException("modelblock.missing", x, y, z);
}
} | 1,055 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelExportObj.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/model/SubCommandModelExportObj.java | package mchorse.blockbuster.commands.model;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.CommonProxy;
import mchorse.blockbuster.api.Model;
import mchorse.blockbuster.api.ModelPose;
import mchorse.blockbuster.client.model.ModelCustom;
import mchorse.blockbuster.client.model.parsing.ModelExporterOBJ;
import mchorse.blockbuster.commands.BBCommandBase;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.TextureUtil;
import net.minecraft.client.resources.IResource;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.BlockPos;
import org.apache.commons.io.FileUtils;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.List;
public class SubCommandModelExportObj extends BBCommandBase
{
@Override
public String getName()
{
return "export_obj";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.model.export_obj";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}model {8}export_obj{r} {7}<model_name> [pose]{r}";
}
@Override
public int getRequiredArgs()
{
return 1;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String modelName = args[0];
ModelCustom model = ModelCustom.MODELS.get(modelName);
if (model == null)
{
throw new CommandException("blockbuster.error.model.export.no_model", modelName);
}
Model data = model.model;
ModelPose pose = args.length >= 2 ? data.getPose(args[1]) : data.getPose("standing");
String obj = new ModelExporterOBJ(data, pose).export(modelName);
/* Save */
String filename = modelName.replaceAll("[^\\w\\d_-]", "_");
File destination = new File(CommonProxy.configFile, "export/" + filename + ".obj");
if (data.defaultTexture != null)
{
try
{
String mtl = "# MTL generated by Blockbuster (version " + Blockbuster.VERSION + ")\n\nnewmtl default\nKd 1.000000 1.000000 1.000000\nNi 1.000000\nd 1.000000\nillum 2\nmap_Kd " + filename + ".png";
File mtlFile = new File(CommonProxy.configFile, "export/" + filename + ".mtl");
FileUtils.writeStringToFile(mtlFile, mtl, StandardCharsets.UTF_8);
}
catch (Exception e)
{}
try
{
IResource resource = Minecraft.getMinecraft().getResourceManager().getResource(data.defaultTexture);
BufferedImage image = TextureUtil.readBufferedImage(resource.getInputStream());
File texture = new File(CommonProxy.configFile, "export/" + filename + ".png");
ImageIO.write(image, "png", texture);
}
catch (Exception e)
{}
}
try
{
FileUtils.writeStringToFile(destination, obj, StandardCharsets.UTF_8);
Blockbuster.l10n.success(sender, "model.export.obj", modelName);
}
catch (Exception e)
{
e.printStackTrace();
Blockbuster.l10n.error(sender, "model.export.obj", modelName);
}
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, ModelCustom.MODELS.keySet());
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 3,854 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelConvertSkin.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/model/SubCommandModelConvertSkin.java | package mchorse.blockbuster.commands.model;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.ClientProxy;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.mclib.commands.SubCommandBase;
import mchorse.mclib.utils.files.GlobalTree;
import mchorse.mclib.utils.files.entries.AbstractEntry;
import mchorse.mclib.utils.files.entries.FolderEntry;
import mchorse.mclib.utils.resources.RLUtils;
import net.minecraft.client.Minecraft;
import net.minecraft.client.resources.IResource;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import org.apache.commons.io.FilenameUtils;
import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Command /model convert
*
* This command is responsible for converting 64x32 skins to 64x64 and
* vice versa.
*/
public class SubCommandModelConvertSkin extends BBCommandBase
{
@Override
public String getName()
{
return "convert";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.model.convert";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}model {8}convert{r} {7}<steve|fred> <skin>{r}";
}
@Override
public int getRequiredArgs()
{
return 2;
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
String model = args[0];
String skin = String.join(" ", SubCommandBase.dropFirstArgument(args));
if (!(model.equals("steve") || model.equals("fred")))
{
throw new CommandException("blockbuster.error.commands.convert_model", model);
}
/* If extension or path exist, then it means we need to use the full path, not
* not the shortened version... */
String path = model + "/" + (skin.contains(".") || skin.contains("/") ? "skins/" + skin : skin);
ResourceLocation location = RLUtils.create("b.a", path);
try
{
IResource resource = Minecraft.getMinecraft().getResourceManager().getResource(location);
BufferedImage image = ImageIO.read(resource.getInputStream());
int w = image.getWidth();
int h = image.getHeight();
boolean one = w == h;
/* Check for correct aspect ratio */
if (!(w % 64 == 0 && h % (one ? 64 : 32) == 0 && (one || w == h * 2)))
{
throw new CommandException("blockbuster.error.commands.convert_skin_size", w, h);
}
BufferedImage target;
if (model.equals("steve"))
{
/* Convert to 64x64 */
target = new BufferedImage(w, h * 2, 2);
Graphics graphics = target.getGraphics();
float s = w / 64F;
/* These coordinates were copied from
* ImageBufferDownload class */
graphics.drawImage(image, 0, 0, null);
graphics.setColor(new Color(0, 0, 0, 0));
graphics.fillRect(0, h / 2, w, h / 2);
this.drawImage(graphics, target, 24, 48, 20, 52, 4, 16, 8, 20, s);
this.drawImage(graphics, target, 28, 48, 24, 52, 8, 16, 12, 20, s);
this.drawImage(graphics, target, 20, 52, 16, 64, 8, 20, 12, 32, s);
this.drawImage(graphics, target, 24, 52, 20, 64, 4, 20, 8, 32, s);
this.drawImage(graphics, target, 28, 52, 24, 64, 0, 20, 4, 32, s);
this.drawImage(graphics, target, 32, 52, 28, 64, 12, 20, 16, 32, s);
this.drawImage(graphics, target, 40, 48, 36, 52, 44, 16, 48, 20, s);
this.drawImage(graphics, target, 44, 48, 40, 52, 48, 16, 52, 20, s);
this.drawImage(graphics, target, 36, 52, 32, 64, 48, 20, 52, 32, s);
this.drawImage(graphics, target, 40, 52, 36, 64, 44, 20, 48, 32, s);
this.drawImage(graphics, target, 44, 52, 40, 64, 40, 20, 44, 32, s);
this.drawImage(graphics, target, 48, 52, 44, 64, 52, 20, 56, 32, s);
}
else
{
/* Else, convert from 64x64 to 64x32 */
target = new BufferedImage(w, h / 2, 2);
Graphics graphics = target.getGraphics();
graphics.drawImage(image, 0, 0, (ImageObserver) null);
}
/* Set target to opposite model */
String targetModel = model.equals("steve") ? "fred" : "steve";
File file = new File(ClientProxy.configFile, "models/" + targetModel + "/skins/" + skin);
file.mkdirs();
ImageIO.write(target, "png", file);
target.flush();
image.flush();
}
catch (CommandException e)
{
throw e;
}
catch (IOException e)
{
e.printStackTrace();
throw new CommandException("blockbuster.error.commands.convert_skin", model, skin, e.getMessage());
}
Blockbuster.l10n.success(sender, "commands.convert_skin", model, skin);
}
/**
* Draw parts of the image to another image using graphics and with
* a custom scale so it could support high resolution skins
*/
private void drawImage(Graphics graphics, BufferedImage image, float a1, float a2, float b1, float b2, float c1, float c2, float d1, float d2, float s)
{
graphics.drawImage(image, (int) (a1 * s), (int) (a2 * s), (int) (b1 * s), (int) (b2 * s), (int) (c1 * s), (int) (c2 * s), (int) (d1 * s), (int) (d2 * s), null);
}
@Override
public List<String> getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos)
{
if (args.length == 1)
{
return getListOfStringsMatchingLastWord(args, "steve", "fred");
}
if (args.length >= 2 && Arrays.asList("steve", "fred").contains(args[0]))
{
String skin = String.join(" ", SubCommandBase.dropFirstArgument(args));
String path = "b.a/" + args[0] + "/skins/" + skin;
FolderEntry skins = GlobalTree.TREE.getByPath(path, null);
String name = FilenameUtils.getBaseName(FilenameUtils.getPathNoEndSeparator(path));
if (skins != null && skins.title.equals(name))
{
List<String> strings = new ArrayList<String>();
String prefix = skin.contains("/") ? skin.substring(0, skin.lastIndexOf("/") + 1) : "";
for (AbstractEntry entry : skins.getEntries())
{
if (entry.title.contains(".."))
{
continue;
}
strings.add(prefix + entry.title);
}
return getListOfStringsMatchingLastWord(args, strings);
}
}
return super.getTabCompletions(server, sender, args, pos);
}
} | 7,382 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
SubCommandModelReport.java | /FileExtraction/Java_unseen/mchorse_blockbuster/src/main/java/mchorse/blockbuster/commands/model/SubCommandModelReport.java | package mchorse.blockbuster.commands.model;
import mchorse.blockbuster.Blockbuster;
import mchorse.blockbuster.ClientProxy;
import mchorse.blockbuster.api.loaders.lazy.IModelLazyLoader;
import mchorse.blockbuster.api.loaders.lazy.ModelLazyLoaderJSON;
import mchorse.blockbuster.api.loaders.lazy.ModelLazyLoaderOBJ;
import mchorse.blockbuster.api.loaders.lazy.ModelLazyLoaderVOX;
import mchorse.blockbuster.commands.BBCommandBase;
import mchorse.mclib.utils.resources.RLUtils;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.texture.ITextureObject;
import net.minecraft.client.renderer.texture.TextureUtil;
import net.minecraft.command.CommandException;
import net.minecraft.command.ICommandSender;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.ResourceLocation;
import java.io.File;
/**
* /model report
*
* This command generates a report of all the files in config/blockbuster/models/
* and copies it to copy-paste buffer.
*/
public class SubCommandModelReport extends BBCommandBase
{
@Override
public String getName()
{
return "report";
}
@Override
public String getUsage(ICommandSender sender)
{
return "blockbuster.commands.model.report";
}
@Override
public String getSyntax()
{
return "{l}{6}/{r}model {8}report{r}";
}
@Override
public void executeCommand(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException
{
File models = new File(ClientProxy.configFile, "models");
StringBuilder output = new StringBuilder();
output.append("Models folder skins report:\n\n");
this.processRecursively(output, models, models, "", "", false);
GuiScreen.setClipboardString(output.toString().trim());
Blockbuster.l10n.success(sender, "commands.model_report");
}
private void processRecursively(StringBuilder output, File root, File models, String prefix, String indent, boolean isModel)
{
if (!models.isDirectory())
{
return;
}
File[] files = models.listFiles();
for (File file : files)
{
if (!file.isFile())
{
continue;
}
String name = file.getName();
String aux = "";
boolean obj = name.endsWith(".obj");
boolean vox = name.endsWith(".vox");
if (!isModel && (obj || name.equals("model.json") || vox))
{
IModelLazyLoader loader = Blockbuster.proxy.pack.models.get(prefix);
if (loader instanceof ModelLazyLoaderOBJ && obj)
{
isModel = true;
aux += ", loaded OBJ";
}
else if (loader instanceof ModelLazyLoaderVOX && vox)
{
isModel = true;
aux += ", loaded VOX";
}
else if (loader != null && loader.getClass() == ModelLazyLoaderJSON.class)
{
isModel = true;
aux += ", loaded JSON";
}
}
if (name.endsWith(".png") || name.endsWith(".jpg") || name.endsWith(".jpeg") || name.endsWith(".gif"))
{
ResourceLocation location = RLUtils.create("b.a:" + (prefix.isEmpty() ? "" : prefix + "/") + name);
ITextureObject texture = Minecraft.getMinecraft().renderEngine.getTexture(location);
if (texture == TextureUtil.MISSING_TEXTURE)
{
aux += ", loaded but missing";
}
else if (texture != null)
{
aux += ", loaded";
}
}
output.append(indent);
output.append(name);
output.append(aux);
output.append("\n");
}
for (File file : files)
{
if (!file.isDirectory())
{
continue;
}
output.append(indent);
output.append(file.getName());
output.append("/\n");
this.processRecursively(output, root, file, prefix.isEmpty() ? file.getName() : prefix + "/" + file.getName(), indent + " ", isModel);
}
}
} | 4,425 | Java | .java | mchorse/blockbuster | 159 | 39 | 10 | 2016-06-17T21:52:40Z | 2024-05-08T20:37:12Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.