mirror of
https://github.com/Sollace/Unicopia.git
synced 2024-12-01 08:47:59 +01:00
341 lines
9.9 KiB
Java
341 lines
9.9 KiB
Java
package com.minelittlepony.unicopia.player;
|
|
|
|
import java.util.List;
|
|
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.minelittlepony.model.anim.BasicEasingInterpolator;
|
|
import com.minelittlepony.model.anim.IInterpolator;
|
|
import com.minelittlepony.unicopia.Race;
|
|
import com.minelittlepony.unicopia.UEffects;
|
|
import com.minelittlepony.unicopia.Unicopia;
|
|
import com.minelittlepony.unicopia.network.EffectSync;
|
|
import com.minelittlepony.unicopia.network.MsgPlayerCapabilities;
|
|
import com.minelittlepony.unicopia.spell.IMagicEffect;
|
|
import com.minelittlepony.unicopia.spell.SpellAffinity;
|
|
import com.minelittlepony.unicopia.spell.SpellRegistry;
|
|
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.init.MobEffects;
|
|
import net.minecraft.item.ItemFood;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagIntArray;
|
|
import net.minecraft.network.datasync.DataParameter;
|
|
import net.minecraft.network.datasync.DataSerializers;
|
|
import net.minecraft.network.datasync.EntityDataManager;
|
|
import net.minecraft.network.play.server.SPacketSetPassengers;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.stats.StatList;
|
|
import net.minecraft.world.EnumDifficulty;
|
|
|
|
class PlayerCapabilities implements IPlayer {
|
|
|
|
private static final DataParameter<Integer> PLAYER_RACE = EntityDataManager
|
|
.createKey(EntityPlayer.class, DataSerializers.VARINT);
|
|
|
|
private static final DataParameter<Float> ENERGY = EntityDataManager
|
|
.createKey(EntityPlayer.class, DataSerializers.FLOAT);
|
|
|
|
private static final DataParameter<Float> EXERTION = EntityDataManager
|
|
.createKey(EntityPlayer.class, DataSerializers.FLOAT);
|
|
|
|
private static final DataParameter<NBTTagCompound> EFFECT = EntityDataManager
|
|
.createKey(EntityPlayer.class, DataSerializers.COMPOUND_TAG);
|
|
|
|
private final List<Integer> pages = Lists.newArrayList();
|
|
|
|
private final PlayerAbilityDelegate powers = new PlayerAbilityDelegate(this);
|
|
|
|
private final PlayerGravityDelegate gravity = new PlayerGravityDelegate(this);
|
|
|
|
private final PlayerAttributes attributes = new PlayerAttributes();
|
|
|
|
private final PlayerView view = new PlayerView(this);
|
|
|
|
private final PlayerFood food = new PlayerFood(this);
|
|
|
|
private final EffectSync<EntityPlayer> effectDelegate = new EffectSync<>(this, EFFECT);
|
|
|
|
private final IInterpolator interpolator = new BasicEasingInterpolator();
|
|
|
|
private float nextStepDistance = 1;
|
|
|
|
private EntityPlayer entity;
|
|
|
|
PlayerCapabilities(EntityPlayer player) {
|
|
setOwner(player);
|
|
|
|
player.getDataManager().register(PLAYER_RACE, Race.EARTH.ordinal());
|
|
player.getDataManager().register(EXERTION, 0F);
|
|
player.getDataManager().register(ENERGY, 0F);
|
|
player.getDataManager().register(EFFECT, new NBTTagCompound());
|
|
}
|
|
|
|
@Override
|
|
public Race getPlayerSpecies() {
|
|
if (getOwner() == null) {
|
|
return Race.HUMAN;
|
|
}
|
|
|
|
return Race.fromId(getOwner().getDataManager().get(PLAYER_RACE));
|
|
}
|
|
|
|
@Override
|
|
public void setPlayerSpecies(Race race) {
|
|
EntityPlayer player = getOwner();
|
|
|
|
if (!PlayerSpeciesList.instance().speciesPermitted(race, player)) {
|
|
race = Race.EARTH;
|
|
|
|
if (!PlayerSpeciesList.instance().speciesPermitted(race, player)) {
|
|
race = Race.HUMAN;
|
|
}
|
|
}
|
|
|
|
player.getDataManager().set(PLAYER_RACE, race.ordinal());
|
|
|
|
player.capabilities.allowFlying = race.canFly();
|
|
gravity.updateFlightStat(player, player.capabilities.isFlying);
|
|
|
|
player.sendPlayerAbilities();
|
|
sendCapabilities(false);
|
|
}
|
|
|
|
@Override
|
|
public float getExertion() {
|
|
return getOwner().getDataManager().get(EXERTION);
|
|
}
|
|
|
|
@Override
|
|
public void setExertion(float exertion) {
|
|
getOwner().getDataManager().set(EXERTION, Math.max(0, exertion));
|
|
}
|
|
|
|
@Override
|
|
public float getEnergy() {
|
|
return getOwner().getDataManager().get(ENERGY);
|
|
}
|
|
|
|
@Override
|
|
public void setEnergy(float energy) {
|
|
getOwner().getDataManager().set(ENERGY, Math.max(0, energy));
|
|
}
|
|
|
|
@Override
|
|
public SpellAffinity getAffinity() {
|
|
return SpellAffinity.NEUTRAL;
|
|
}
|
|
|
|
@Override
|
|
public void sendCapabilities(boolean full) {
|
|
if (!getOwner().getEntityWorld().isRemote) {
|
|
if (full) {
|
|
Unicopia.channel.broadcast(new MsgPlayerCapabilities(this));
|
|
} else {
|
|
Unicopia.channel.broadcast(new MsgPlayerCapabilities(getPlayerSpecies(), getOwner()));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public IAbilityReceiver getAbilities() {
|
|
return powers;
|
|
}
|
|
|
|
@Override
|
|
public IGravity getGravity() {
|
|
return gravity;
|
|
}
|
|
|
|
@Override
|
|
public IView getCamera() {
|
|
return view;
|
|
}
|
|
|
|
@Override
|
|
public IInterpolator getInterpolator() {
|
|
return interpolator;
|
|
}
|
|
|
|
@Override
|
|
public void beforeUpdate(EntityPlayer entity) {
|
|
if (entity.world.isRemote) {
|
|
if (entity.isRiding() && entity.isSneaking()) {
|
|
|
|
Entity ridee = entity.getRidingEntity();
|
|
|
|
entity.dismountRidingEntity();
|
|
|
|
if (ridee instanceof EntityPlayerMP) {
|
|
((EntityPlayerMP)ridee).getServerWorld().getEntityTracker().sendToTrackingAndSelf(ridee, new SPacketSetPassengers(ridee));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate(EntityPlayer entity) {
|
|
powers.onUpdate(entity);
|
|
gravity.onUpdate(entity);
|
|
|
|
if (hasEffect()) {
|
|
if (!getPlayerSpecies().canCast()) {
|
|
setEffect(null);
|
|
} else {
|
|
if (entity.getEntityWorld().isRemote) {
|
|
getEffect().renderOnPerson(this);
|
|
}
|
|
|
|
if (!getEffect().updateOnPerson(this)) {
|
|
setEffect(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
addExertion(-1);
|
|
addEnergy(-1);
|
|
|
|
attributes.applyAttributes(entity, getPlayerSpecies());
|
|
}
|
|
|
|
@Override
|
|
public void onFall(float distance, float damageMultiplier) {
|
|
if (!entity.getEntityWorld().isRemote) {
|
|
if (getPlayerSpecies().canFly()) {
|
|
if (entity.fallDistance > 2) {
|
|
entity.addStat(StatList.FALL_ONE_CM, (int)Math.round(distance * 100));
|
|
}
|
|
|
|
gravity.landHard(entity, distance, damageMultiplier);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean stepOnCloud() {
|
|
EntityPlayer player = getOwner();
|
|
|
|
if (player.fallDistance > 1 || player.distanceWalkedOnStepModified > nextStepDistance) {
|
|
nextStepDistance = player.distanceWalkedOnStepModified + 2;
|
|
player.fallDistance = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public IFood getFood() {
|
|
return food;
|
|
}
|
|
|
|
@Override
|
|
public void onEntityEat(ItemStack stack, @Nullable ItemFood food) {
|
|
if (getPlayerSpecies() == Race.CHANGELING) {
|
|
EntityPlayer player = getOwner();
|
|
|
|
if (food != null) {
|
|
int health = food.getHealAmount(stack);
|
|
float saturation = food.getSaturationModifier(stack);
|
|
|
|
player.getFoodStats().addStats(-health/2, -saturation/2);
|
|
|
|
player.addPotionEffect(new PotionEffect(MobEffects.NAUSEA, 100, 3, true, true));
|
|
} else {
|
|
player.addPotionEffect(new PotionEffect(MobEffects.NAUSEA, 200, 3, true, true));
|
|
}
|
|
|
|
if (player.world.getDifficulty() != EnumDifficulty.PEACEFUL && player.world.rand.nextInt(20) == 0) {
|
|
player.addPotionEffect(new PotionEffect(UEffects.FOOD_POISONING, 3, 2, true, true));
|
|
}
|
|
|
|
player.addPotionEffect(new PotionEffect(MobEffects.WEAKNESS, 2000, 2, true, true));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound compound) {
|
|
compound.setString("playerSpecies", getPlayerSpecies().name());
|
|
|
|
compound.setTag("powers", powers.toNBT());
|
|
compound.setTag("gravity", gravity.toNBT());
|
|
|
|
if (hasUnlockedPages()) {
|
|
compound.setTag("pages", new NBTTagIntArray(pages));
|
|
}
|
|
|
|
IMagicEffect effect = getEffect();
|
|
|
|
if (effect != null) {
|
|
compound.setTag("effect", SpellRegistry.instance().serializeEffectToNBT(effect));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound compound) {
|
|
setPlayerSpecies(Race.fromName(compound.getString("playerSpecies")));
|
|
|
|
powers.readFromNBT(compound.getCompoundTag("powers"));
|
|
gravity.readFromNBT(compound.getCompoundTag("gravity"));
|
|
|
|
if (compound.hasKey("effect")) {
|
|
setEffect(SpellRegistry.instance().createEffectFromNBT(compound.getCompoundTag("effect")));
|
|
}
|
|
|
|
if (compound.hasKey("pages")) {
|
|
pages.clear();
|
|
for (int i : compound.getIntArray("pages")) {
|
|
pages.add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void copyFrom(IPlayer oldPlayer) {
|
|
setEffect(oldPlayer.getEffect());
|
|
setPlayerSpecies(oldPlayer.getPlayerSpecies());
|
|
}
|
|
|
|
@Override
|
|
public void setEffect(IMagicEffect effect) {
|
|
effectDelegate.set(effect);
|
|
|
|
sendCapabilities(true);
|
|
}
|
|
|
|
@Override
|
|
public IMagicEffect getEffect() {
|
|
return effectDelegate.get();
|
|
}
|
|
|
|
@Override
|
|
public void setOwner(EntityPlayer owner) {
|
|
entity = owner;
|
|
}
|
|
|
|
@Override
|
|
public EntityPlayer getOwner() {
|
|
return entity;
|
|
}
|
|
|
|
@Override
|
|
public int getCurrentLevel() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void setCurrentLevel(int level) {
|
|
}
|
|
|
|
@Nonnull
|
|
public List<Integer> getUnlockedPages() {
|
|
return pages;
|
|
}
|
|
|
|
}
|