diff options
Diffstat (limited to '')
59 files changed, 2156 insertions, 2 deletions
diff --git a/src/Mobs/CMakeLists.txt b/src/Mobs/CMakeLists.txt index 060c012fc..1cb01443e 100644 --- a/src/Mobs/CMakeLists.txt +++ b/src/Mobs/CMakeLists.txt @@ -36,7 +36,34 @@ SET (SRCS Wither.cpp Wolf.cpp Zombie.cpp - ZombiePigman.cpp) + ZombiePigman.cpp + NewBat.cpp + NewBlaze.cpp + NewCaveSpider.cpp + NewChicken.cpp + NewCow.cpp + NewCreeper.cpp + NewEnderDragon.cpp + NewEnderman.cpp + NewGhast.cpp + NewGiant.cpp + NewHorse.cpp + NewIronGolem.cpp + NewMagmaCube.cpp + NewMooshroom.cpp + NewPig.cpp + NewSheep.cpp + NewSkeleton.cpp + NewSlime.cpp + NewSnowGolem.cpp + NewSpider.cpp + NewSquid.cpp + NewVillager.cpp + NewWitch.cpp + NewWither.cpp + NewWolf.cpp + NewZombie.cpp + NewZombiePigman.cpp) SET (HDRS AggressiveMonster.h @@ -73,7 +100,36 @@ SET (HDRS Wither.h Wolf.h Zombie.h - ZombiePigman.h) + ZombiePigman.h + NewBat.h + NewBlaze.h + NewCaveSpider.h + NewChicken.h + NewCow.h + NewCreeper.h + NewEnderDragon.h + NewEnderman.h + NewGhast.h + NewGiant.h + NewHorse.h + NewIronGolem.h + NewMagmaCube.h + NewMooshroom.h + NewOcelot.h + NewPig.h + NewSheep.h + NewSilverfish.h + NewSkeleton.h + NewSlime.h + NewSnowGolem.h + NewSpider.h + NewSquid.h + NewVillager.h + NewWitch.h + NewWither.h + NewWolf.h + NewZombie.h + NewZombiePigman.h) if(NOT MSVC) add_library(Mobs ${SRCS} ${HDRS}) diff --git a/src/Mobs/NewBat.cpp b/src/Mobs/NewBat.cpp new file mode 100644 index 000000000..2de28d63a --- /dev/null +++ b/src/Mobs/NewBat.cpp @@ -0,0 +1,14 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewBat.h" +#include "../Vector3.h" +#include "../Chunk.h" + + +cNewBat::cNewBat(void) : + super("Bat", mtBat, "mob.bat.hurt", "mob.bat.death", 0.5, 0.9) +{ +} + + diff --git a/src/Mobs/NewBat.h b/src/Mobs/NewBat.h new file mode 100644 index 000000000..354413cdf --- /dev/null +++ b/src/Mobs/NewBat.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewBat : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewBat(void); + + CLASS_PROTODEF(cNewBat) + + bool IsHanging(void) const {return false; } +} ; + + + + diff --git a/src/Mobs/NewBlaze.cpp b/src/Mobs/NewBlaze.cpp new file mode 100644 index 000000000..699a14227 --- /dev/null +++ b/src/Mobs/NewBlaze.cpp @@ -0,0 +1,27 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewBlaze.h" +#include "../World.h" +#include "../Entities/FireChargeEntity.h" + + + + +cNewBlaze::cNewBlaze(void) : + super("Blaze", mtBlaze, "mob.blaze.hit", "mob.blaze.death", 0.6, 1.8) +{ +} + + + + + +void cNewBlaze::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf"))) + { + int LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_BLAZE_ROD); + } +} diff --git a/src/Mobs/NewBlaze.h b/src/Mobs/NewBlaze.h new file mode 100644 index 000000000..eebe491f5 --- /dev/null +++ b/src/Mobs/NewBlaze.h @@ -0,0 +1,21 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewBlaze : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewBlaze(void); + + CLASS_PROTODEF(cNewBlaze) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; diff --git a/src/Mobs/NewCaveSpider.cpp b/src/Mobs/NewCaveSpider.cpp new file mode 100644 index 000000000..c3acb926b --- /dev/null +++ b/src/Mobs/NewCaveSpider.cpp @@ -0,0 +1,44 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewCaveSpider.h" +#include "../World.h" + + + + + +cNewCaveSpider::cNewCaveSpider(void) : + super("CaveSpider", mtCaveSpider, "mob.spider.say", "mob.spider.death", 0.7, 0.5) +{ +} + + + + + +void cNewCaveSpider::Tick(float a_Dt, cChunk & a_Chunk) +{ + super::Tick(a_Dt, a_Chunk); +} + + + + + +void cNewCaveSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING); + if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf"))) + { + AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE); + } +} + + + + diff --git a/src/Mobs/NewCaveSpider.h b/src/Mobs/NewCaveSpider.h new file mode 100644 index 000000000..3e52189a0 --- /dev/null +++ b/src/Mobs/NewCaveSpider.h @@ -0,0 +1,25 @@ +#pragma once + +#include "NewMonster.h" + + + + + +class cNewCaveSpider : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewCaveSpider(void); + + CLASS_PROTODEF(cNewCaveSpider) + + virtual void Tick(float a_Dt, cChunk & a_Chunk) override; + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewChicken.cpp b/src/Mobs/NewChicken.cpp new file mode 100644 index 000000000..6c61507f2 --- /dev/null +++ b/src/Mobs/NewChicken.cpp @@ -0,0 +1,66 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewChicken.h" +#include "../World.h" + + + + + + + +cNewChicken::cNewChicken(void) : + super("Chicken", mtChicken, "mob.chicken.hurt", "mob.chicken.hurt", 0.3, 0.4), + m_EggDropTimer(0) +{ +} + + + + +void cNewChicken::Tick(float a_Dt, cChunk & a_Chunk) +{ + super::Tick(a_Dt, a_Chunk); + + if ((m_EggDropTimer == 6000) && (m_World->GetTickRandomNumber(1) == 0)) + { + cItems Drops; + m_EggDropTimer = 0; + Drops.push_back(cItem(E_ITEM_EGG, 1)); + m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10); + } + else if (m_EggDropTimer == 12000) + { + cItems Drops; + m_EggDropTimer = 0; + Drops.push_back(cItem(E_ITEM_EGG, 1)); + m_World->SpawnItemPickups(Drops, GetPosX(), GetPosY(), GetPosZ(), 10); + } + else + { + m_EggDropTimer++; + } +} + + + + + +void cNewChicken::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_FEATHER); + AddRandomDropItem(a_Drops, 1, 1, IsOnFire() ? E_ITEM_COOKED_CHICKEN : E_ITEM_RAW_CHICKEN); +} + + + + + + + + diff --git a/src/Mobs/NewChicken.h b/src/Mobs/NewChicken.h new file mode 100644 index 000000000..4323585e6 --- /dev/null +++ b/src/Mobs/NewChicken.h @@ -0,0 +1,28 @@ +#pragma once + +#include "NewMonster.h" + + + + + +class cNewChicken : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewChicken(void); + + CLASS_PROTODEF(cNewChicken) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + virtual void Tick(float a_Dt, cChunk & a_Chunk) override; + +private: + + int m_EggDropTimer; +} ; + + + diff --git a/src/Mobs/NewCow.cpp b/src/Mobs/NewCow.cpp new file mode 100644 index 000000000..8009a5f0d --- /dev/null +++ b/src/Mobs/NewCow.cpp @@ -0,0 +1,33 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewCow.h" +#include "../Entities/Player.h" + + + + + + + +cNewCow::cNewCow(void) : + super("Cow", mtCow, "mob.cow.hurt", "mob.cow.hurt", 0.9, 1.3) +{ +} + + + + + +void cNewCow::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER); + AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF); +} + + diff --git a/src/Mobs/NewCow.h b/src/Mobs/NewCow.h new file mode 100644 index 000000000..b0c770e84 --- /dev/null +++ b/src/Mobs/NewCow.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewCow : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewCow(); + + CLASS_PROTODEF(cNewCow) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewCreeper.cpp b/src/Mobs/NewCreeper.cpp new file mode 100644 index 000000000..a6f5e0e4d --- /dev/null +++ b/src/Mobs/NewCreeper.cpp @@ -0,0 +1,69 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewCreeper.h" +#include "../World.h" +#include "../Entities/ProjectileEntity.h" +#include "../Entities/Player.h" +#include "../Entities/Entity.h" + + + + + +cNewCreeper::cNewCreeper(void) : + super("Creeper", mtCreeper, "mob.creeper.say", "mob.creeper.say", 0.6, 1.8), + m_bIsBlowing(false), + m_bIsCharged(false), + // m_BurnedWithFlintAndSteel(false), + m_ExplodingTimer(0) +{ +} + + + + + +void cNewCreeper::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + if (m_ExplodingTimer == 30) + { + // Exploded creepers drop naught but charred flesh, which Minecraft doesn't have + return; + } + + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER); + + if ((a_Killer != NULL) && a_Killer->IsProjectile() && (((cProjectileEntity *)a_Killer)->GetCreatorUniqueID() >= 0)) + { + class cProjectileCreatorCallback : public cEntityCallback + { + public: + cProjectileCreatorCallback(void) + { + } + + virtual bool Item(cEntity * a_Entity) override + { + if (a_Entity->IsMob() && ((cNewMonster *)a_Entity)->GetMobType() == mtSkeleton) + { + return true; + } + return false; + } + }; + + cProjectileCreatorCallback PCC; + if (GetWorld()->DoWithEntityByID(((cProjectileEntity *)a_Killer)->GetCreatorUniqueID(), PCC)) + { + // 12 music discs. TickRand starts from 0 to 11. Disk IDs start at 2256, so add that. There. + AddRandomDropItem(a_Drops, 1, 1, (short)m_World->GetTickRandomNumber(11) + 2256); + } + } +} + diff --git a/src/Mobs/NewCreeper.h b/src/Mobs/NewCreeper.h new file mode 100644 index 000000000..61a16bf68 --- /dev/null +++ b/src/Mobs/NewCreeper.h @@ -0,0 +1,34 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewCreeper : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewCreeper(void); + + CLASS_PROTODEF(cNewCreeper) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsBlowing(void) const {return m_bIsBlowing; } + bool IsCharged(void) const {return m_bIsCharged; } + +private: + + bool m_bIsBlowing, m_bIsCharged/*, m_BurnedWithFlintAndSteel*/; + int m_ExplodingTimer; + +} ; + + + + diff --git a/src/Mobs/NewEnderDragon.cpp b/src/Mobs/NewEnderDragon.cpp new file mode 100644 index 000000000..7ed9ab25a --- /dev/null +++ b/src/Mobs/NewEnderDragon.cpp @@ -0,0 +1,27 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewEnderDragon.h" + + + + + +cNewEnderDragon::cNewEnderDragon(void) : + // TODO: Vanilla source says this, but is it right? Dragons fly, they don't stand + super("EnderDragon", mtEnderDragon, "mob.enderdragon.hit", "mob.enderdragon.end", 16.0, 8.0) +{ +} + + + + + +void cNewEnderDragon::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + return; +} + + + + diff --git a/src/Mobs/NewEnderDragon.h b/src/Mobs/NewEnderDragon.h new file mode 100644 index 000000000..524124f18 --- /dev/null +++ b/src/Mobs/NewEnderDragon.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewEnderDragon : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewEnderDragon(void); + + CLASS_PROTODEF(cNewEnderDragon) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewEnderman.cpp b/src/Mobs/NewEnderman.cpp new file mode 100644 index 000000000..5a61265d7 --- /dev/null +++ b/src/Mobs/NewEnderman.cpp @@ -0,0 +1,32 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewEnderman.h" +#include "../Entities/Player.h" +#include "../Tracer.h" + + + + + +cNewEnderman::cNewEnderman(void) : + super("Enderman", mtEnderman, "mob.endermen.hit", "mob.endermen.death", 0.5, 2.9), + m_bIsScreaming(false), + CarriedBlock(E_BLOCK_AIR), + CarriedMeta(0) +{ +} + + + + + +void cNewEnderman::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_ENDER_PEARL); +} diff --git a/src/Mobs/NewEnderman.h b/src/Mobs/NewEnderman.h new file mode 100644 index 000000000..1a0a9a81b --- /dev/null +++ b/src/Mobs/NewEnderman.h @@ -0,0 +1,36 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewEnderman : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewEnderman(void); + + CLASS_PROTODEF(cNewEnderman) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsScreaming(void) const {return m_bIsScreaming; } + BLOCKTYPE GetCarriedBlock(void) const {return CarriedBlock; } + NIBBLETYPE GetCarriedMeta(void) const {return CarriedMeta; } + +private: + + bool m_bIsScreaming; + BLOCKTYPE CarriedBlock; + NIBBLETYPE CarriedMeta; + +} ; + + + + diff --git a/src/Mobs/NewGhast.cpp b/src/Mobs/NewGhast.cpp new file mode 100644 index 000000000..eb49a7a4f --- /dev/null +++ b/src/Mobs/NewGhast.cpp @@ -0,0 +1,32 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewGhast.h" +#include "../World.h" +#include "../Entities/GhastFireballEntity.h" + + + + +cNewGhast::cNewGhast(void) : + super("Ghast", mtGhast, "mob.ghast.scream", "mob.ghast.death", 4, 4) +{ +} + + + + + +void cNewGhast::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER); + AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_GHAST_TEAR); +} + + + diff --git a/src/Mobs/NewGhast.h b/src/Mobs/NewGhast.h new file mode 100644 index 000000000..d0af768c5 --- /dev/null +++ b/src/Mobs/NewGhast.h @@ -0,0 +1,27 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewGhast : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewGhast(void); + + CLASS_PROTODEF(cNewGhast) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsCharging(void) const {return false; } +} ; + + + + diff --git a/src/Mobs/NewGiant.cpp b/src/Mobs/NewGiant.cpp new file mode 100644 index 000000000..a6bb0b3ed --- /dev/null +++ b/src/Mobs/NewGiant.cpp @@ -0,0 +1,27 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewGiant.h" + + + + + +cNewGiant::cNewGiant(void) : + super("Giant", mtGiant, "mob.zombie.hurt", "mob.zombie.death", 3.6, 10.8) +{ + +} + + + + + +void cNewGiant::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + AddRandomDropItem(a_Drops, 10, 50, E_ITEM_ROTTEN_FLESH); +} + + + + diff --git a/src/Mobs/NewGiant.h b/src/Mobs/NewGiant.h new file mode 100644 index 000000000..823cb9638 --- /dev/null +++ b/src/Mobs/NewGiant.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewGiant : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewGiant(void); + + CLASS_PROTODEF(cNewGiant) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewHorse.cpp b/src/Mobs/NewHorse.cpp new file mode 100644 index 000000000..2d02aeed2 --- /dev/null +++ b/src/Mobs/NewHorse.cpp @@ -0,0 +1,109 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewHorse.h" +#include "../World.h" +#include "../Entities/Player.h" + + + + + +cNewHorse::cNewHorse(int Type, int Color, int Style, int TameTimes) : + super("Horse", mtHorse, "mob.horse.hit", "mob.horse.death", 1.4, 1.6), + m_bHasChest(false), + m_bIsEating(false), + m_bIsRearing(false), + m_bIsMouthOpen(false), + m_bIsTame(false), + m_bIsSaddled(false), + m_Type(Type), + m_Color(Color), + m_Style(Style), + m_Armour(0), + m_TimesToTame(TameTimes), + m_TameAttemptTimes(0), + m_RearTickCount(0) +{ +} + + + + + +void cNewHorse::Tick(float a_Dt, cChunk & a_Chunk) +{ + super::Tick(a_Dt, a_Chunk); + + if (!m_bIsMouthOpen) + { + if (m_World->GetTickRandomNumber(50) == 25) + { + m_bIsMouthOpen = true; + } + } + else + { + if (m_World->GetTickRandomNumber(10) == 5) + { + m_bIsMouthOpen = false; + } + } + + if ((m_Attachee != NULL) && (!m_bIsTame)) + { + if (m_TameAttemptTimes < m_TimesToTame) + { + if (m_World->GetTickRandomNumber(50) == 25) + { + m_World->BroadcastSoundParticleEffect(2000, (int)GetPosX(), (int)GetPosY(), (int)GetPosZ(), 0); + m_World->BroadcastSoundParticleEffect(2000, (int)GetPosX(), (int)GetPosY(), (int)GetPosZ(), 2); + m_World->BroadcastSoundParticleEffect(2000, (int)GetPosX(), (int)GetPosY(), (int)GetPosZ(), 6); + m_World->BroadcastSoundParticleEffect(2000, (int)GetPosX(), (int)GetPosY(), (int)GetPosZ(), 8); + + m_Attachee->Detach(); + m_bIsRearing = true; + } + } + else + { + m_bIsTame = true; + } + } + + if (m_bIsRearing) + { + if (m_RearTickCount == 20) + { + m_bIsRearing = false; + m_RearTickCount = 0; + } + else + { + m_RearTickCount++; + } + } + + m_World->BroadcastEntityMetadata(*this); +} + + + + + +void cNewHorse::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER); + if (m_bIsSaddled) + { + a_Drops.push_back(cItem(E_ITEM_SADDLE, 1)); + } +} + + + + diff --git a/src/Mobs/NewHorse.h b/src/Mobs/NewHorse.h new file mode 100644 index 000000000..8eadf01d4 --- /dev/null +++ b/src/Mobs/NewHorse.h @@ -0,0 +1,43 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewHorse : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewHorse(int Type, int Color, int Style, int TameTimes); + + CLASS_PROTODEF(cNewHorse) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + virtual void Tick(float a_Dt, cChunk & a_Chunk) override; + + bool IsSaddled (void) const {return m_bIsSaddled; } + bool IsChested (void) const {return m_bHasChest; } + bool IsEating (void) const {return m_bIsEating; } + bool IsRearing (void) const {return m_bIsRearing; } + bool IsMthOpen (void) const {return m_bIsMouthOpen; } + bool IsTame (void) const {return m_bIsTame; } + int GetHorseType (void) const {return m_Type; } + int GetHorseColor (void) const {return m_Color; } + int GetHorseStyle (void) const {return m_Style; } + int GetHorseArmour (void) const {return m_Armour;} + +private: + + bool m_bHasChest, m_bIsEating, m_bIsRearing, m_bIsMouthOpen, m_bIsTame, m_bIsSaddled; + int m_Type, m_Color, m_Style, m_Armour, m_TimesToTame, m_TameAttemptTimes, m_RearTickCount; + +} ; + + + + diff --git a/src/Mobs/NewIronGolem.cpp b/src/Mobs/NewIronGolem.cpp new file mode 100644 index 000000000..0fa3eadee --- /dev/null +++ b/src/Mobs/NewIronGolem.cpp @@ -0,0 +1,28 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewIronGolem.h" + + + + + +cNewIronGolem::cNewIronGolem(void) : + super("IronGolem", mtIronGolem, "mob.IronGolem.hit", "mob.IronGolem.death", 1.4, 2.9) +{ +} + + + + + +void cNewIronGolem::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + UNUSED(a_Killer); + AddRandomDropItem(a_Drops, 0, 5, E_ITEM_IRON); + AddRandomDropItem(a_Drops, 0, 2, E_BLOCK_FLOWER); +} + + + + diff --git a/src/Mobs/NewIronGolem.h b/src/Mobs/NewIronGolem.h new file mode 100644 index 000000000..6cd86b237 --- /dev/null +++ b/src/Mobs/NewIronGolem.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewIronGolem : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewIronGolem(void); + + CLASS_PROTODEF(cNewIronGolem) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewMagmaCube.cpp b/src/Mobs/NewMagmaCube.cpp new file mode 100644 index 000000000..931adf12d --- /dev/null +++ b/src/Mobs/NewMagmaCube.cpp @@ -0,0 +1,30 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewMagmaCube.h" + + + + + +cNewMagmaCube::cNewMagmaCube(int a_Size) : + super("MagmaCube", mtMagmaCube, "mob.MagmaCube.big", "mob.MagmaCube.big", 0.6 * a_Size, 0.6 * a_Size), + m_Size(a_Size) +{ +} + + + + + +void cNewMagmaCube::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + UNUSED(a_Killer); + if (GetSize() > 1) + { + AddRandomUncommonDropItem(a_Drops, 25.0f, E_ITEM_MAGMA_CREAM); + } +} + + + + diff --git a/src/Mobs/NewMagmaCube.h b/src/Mobs/NewMagmaCube.h new file mode 100644 index 000000000..f55f0164a --- /dev/null +++ b/src/Mobs/NewMagmaCube.h @@ -0,0 +1,31 @@ +#pragma once + +#include "NewMonster.h" + + + + + +class cNewMagmaCube : + public cNewMonster +{ + typedef cNewMonster super; + +public: + /// Creates a MagmaCube of the specified size; size is 1 .. 3, with 1 being the smallest + cNewMagmaCube(int a_Size); + + CLASS_PROTODEF(cNewMagmaCube) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + int GetSize(void) const { return m_Size; } + +protected: + + /// Size of the MagmaCube, 1 .. 3, with 1 being the smallest + int m_Size; +} ; + + + + diff --git a/src/Mobs/NewMonster.cpp b/src/Mobs/NewMonster.cpp index 3245bd83d..feeac2489 100644 --- a/src/Mobs/NewMonster.cpp +++ b/src/Mobs/NewMonster.cpp @@ -1,6 +1,7 @@ #include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules #include "NewMonster.h" #include "../ClientHandle.h" +#include "../MersenneTwister.h" cNewMonster::cNewMonster(const AString & a_ConfigName, eType a_MobType, const AString & a_SoundHurt, const AString & a_SoundDeath, double a_Width, double a_Height) : super(etMonster, a_Width, a_Height) @@ -14,8 +15,95 @@ cNewMonster::cNewMonster(const AString & a_ConfigName, eType a_MobType, const AS m_Movement = new cMovementComponent(this); } + + + + void cNewMonster::SpawnOn(cClientHandle & a_Client) { a_Client.SendSpawnMob(*this); } + + + + +void cNewMonster::AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth) +{ + MTRand r1; + int Count = r1.randInt() % (a_Max + 1 - a_Min) + a_Min; + if (Count > 0) + { + a_Drops.push_back(cItem(a_Item, Count, a_ItemHealth)); + } +} + + + + + +void cNewMonster::AddRandomUncommonDropItem(cItems & a_Drops, float a_Chance, short a_Item, short a_ItemHealth) +{ + MTRand r1; + int Count = r1.randInt() % 1000; + if (Count < (a_Chance * 10)) + { + a_Drops.push_back(cItem(a_Item, 1, a_ItemHealth)); + } +} + + + + + +void cNewMonster::AddRandomRareDropItem(cItems & a_Drops, cItems & a_Items, short a_LootingLevel) +{ + MTRand r1; + int Count = r1.randInt() % 200; + if (Count < (5 + a_LootingLevel)) + { + int Rare = r1.randInt() % a_Items.Size(); + a_Drops.push_back(a_Items.at(Rare)); + } +} + + + + + +void cNewMonster::AddRandomArmorDropItem(cItems & a_Drops, short a_LootingLevel) +{ + MTRand r1; + if (r1.randInt() % 200 < ((m_DropChanceHelmet * 200) + (a_LootingLevel * 2))) + { + if (!GetEquippedHelmet().IsEmpty()) a_Drops.push_back(GetEquippedHelmet()); + } + + if (r1.randInt() % 200 < ((m_DropChanceChestplate * 200) + (a_LootingLevel * 2))) + { + if (!GetEquippedChestplate().IsEmpty()) a_Drops.push_back(GetEquippedChestplate()); + } + + if (r1.randInt() % 200 < ((m_DropChanceLeggings * 200) + (a_LootingLevel * 2))) + { + if (!GetEquippedLeggings().IsEmpty()) a_Drops.push_back(GetEquippedLeggings()); + } + + if (r1.randInt() % 200 < ((m_DropChanceBoots * 200) + (a_LootingLevel * 2))) + { + if (!GetEquippedBoots().IsEmpty()) a_Drops.push_back(GetEquippedBoots()); + } +} + + + + + +void cNewMonster::AddRandomWeaponDropItem(cItems & a_Drops, short a_LootingLevel) +{ + MTRand r1; + if (r1.randInt() % 200 < ((m_DropChanceWeapon * 200) + (a_LootingLevel * 2))) + { + if (!GetEquippedWeapon().IsEmpty()) a_Drops.push_back(GetEquippedWeapon()); + } +} diff --git a/src/Mobs/NewMonster.h b/src/Mobs/NewMonster.h index 074538762..cfcfb4db5 100644 --- a/src/Mobs/NewMonster.h +++ b/src/Mobs/NewMonster.h @@ -62,6 +62,23 @@ public: eType GetMobType() const { return m_MobType; } protected: + + + /** Adds a random number of a_Item between a_Min and a_Max to itemdrops a_Drops*/ + void AddRandomDropItem(cItems & a_Drops, unsigned int a_Min, unsigned int a_Max, short a_Item, short a_ItemHealth = 0); + + /** Adds a item a_Item with the chance of a_Chance (in percent) to itemdrops a_Drops*/ + void AddRandomUncommonDropItem(cItems & a_Drops, float a_Chance, short a_Item, short a_ItemHealth = 0); + + /** Adds one rare item out of the list of rare items a_Items modified by the looting level a_LootingLevel(I-III or custom) to the itemdrop a_Drops*/ + void AddRandomRareDropItem(cItems & a_Drops, cItems & a_Items, short a_LootingLevel); + + /** Adds armor that is equipped with the chance saved in m_DropChance[...] (this will be greter than 1 if piccked up or 0.085 + (0.01 per LootingLevel) if born with) to the drop*/ + void AddRandomArmorDropItem(cItems & a_Drops, short a_LootingLevel); + + /** Adds weapon that is equipped with the chance saved in m_DropChance[...] (this will be greter than 1 if piccked up or 0.085 + (0.01 per LootingLevel) if born with) to the drop*/ + void AddRandomWeaponDropItem(cItems & a_Drops, short a_LootingLevel); + AString m_SoundHurt; AString m_SoundDeath; @@ -69,4 +86,11 @@ protected: cAttackComponent * m_Attack; cEnvironmentComponent * m_Environment; cMovementComponent * m_Movement; + + // Temporary placement till I figure out where to put it + float m_DropChanceWeapon; + float m_DropChanceHelmet; + float m_DropChanceChestplate; + float m_DropChanceLeggings; + float m_DropChanceBoots; }; diff --git a/src/Mobs/NewMooshroom.cpp b/src/Mobs/NewMooshroom.cpp new file mode 100644 index 000000000..c9362b0f2 --- /dev/null +++ b/src/Mobs/NewMooshroom.cpp @@ -0,0 +1,35 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewMooshroom.h" +#include "../Entities/Player.h" + + + + + + + + + + +cNewMooshroom::cNewMooshroom(void) : + super("Mooshroom", mtMooshroom, "mob.cow.hurt", "mob.cow.hurt", 0.9, 1.3) +{ +} + + + + + +void cNewMooshroom::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_LEATHER); + AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_STEAK : E_ITEM_RAW_BEEF); +} + diff --git a/src/Mobs/NewMooshroom.h b/src/Mobs/NewMooshroom.h new file mode 100644 index 000000000..2e10ad0a3 --- /dev/null +++ b/src/Mobs/NewMooshroom.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewMooshroom : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewMooshroom(void); + + CLASS_PROTODEF(cNewMooshroom) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewOcelot.h b/src/Mobs/NewOcelot.h new file mode 100644 index 000000000..c1eb3b9e3 --- /dev/null +++ b/src/Mobs/NewOcelot.h @@ -0,0 +1,26 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewOcelot : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewOcelot(void) : + super("Ocelot", mtOcelot, "mob.cat.hitt", "mob.cat.hitt", 0.6, 0.8) + { + } + + CLASS_PROTODEF(cNewOcelot) +} ; + + + + diff --git a/src/Mobs/NewPig.cpp b/src/Mobs/NewPig.cpp new file mode 100644 index 000000000..c5fbddfd0 --- /dev/null +++ b/src/Mobs/NewPig.cpp @@ -0,0 +1,38 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewPig.h" +#include "../Entities/Player.h" +#include "../World.h" + + + + + +cNewPig::cNewPig(void) : + super("Pig", mtPig, "mob.pig.say", "mob.pig.death", 0.9, 0.9), + m_bIsSaddled(false) +{ +} + + + + + +void cNewPig::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 1, 3 + LootingLevel, IsOnFire() ? E_ITEM_COOKED_PORKCHOP : E_ITEM_RAW_PORKCHOP); + if (m_bIsSaddled) + { + a_Drops.push_back(cItem(E_ITEM_SADDLE, 1)); + } +} + + + + diff --git a/src/Mobs/NewPig.h b/src/Mobs/NewPig.h new file mode 100644 index 000000000..2255c44c8 --- /dev/null +++ b/src/Mobs/NewPig.h @@ -0,0 +1,32 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewPig : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewPig(void); + + CLASS_PROTODEF(cNewPig) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsSaddled(void) const { return m_bIsSaddled; } + +private: + + bool m_bIsSaddled; + +} ; + + + + diff --git a/src/Mobs/NewSheep.cpp b/src/Mobs/NewSheep.cpp new file mode 100644 index 000000000..78e3418e8 --- /dev/null +++ b/src/Mobs/NewSheep.cpp @@ -0,0 +1,78 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSheep.h" +#include "../BlockID.h" +#include "../Entities/Player.h" +#include "../World.h" +#include "FastRandom.h" + + + + + +cNewSheep::cNewSheep(int a_Color) : + super("Sheep", mtSheep, "mob.sheep.say", "mob.sheep.say", 0.6, 1.3), + m_IsSheared(false), + m_WoolColor(a_Color) + // m_TimeToStopEating(-1) +{ + // Generate random wool color. + if (m_WoolColor == -1) + { + m_WoolColor = GenerateNaturalRandomColor(); + } + + if ((m_WoolColor < 0) || (m_WoolColor > 15)) + { + m_WoolColor = 0; + } +} + + + + + +void cNewSheep::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + if (!m_IsSheared) + { + a_Drops.push_back(cItem(E_BLOCK_WOOL, 1, m_WoolColor)); + } +} + + + + + +NIBBLETYPE cNewSheep::GenerateNaturalRandomColor(void) +{ + cFastRandom Random; + int Chance = Random.NextInt(101); + + if (Chance <= 81) + { + return E_META_WOOL_WHITE; + } + else if (Chance <= 86) + { + return E_META_WOOL_BLACK; + } + else if (Chance <= 91) + { + return E_META_WOOL_GRAY; + } + else if (Chance <= 96) + { + return E_META_WOOL_LIGHTGRAY; + } + else if (Chance <= 99) + { + return E_META_WOOL_BROWN; + } + else + { + return E_META_WOOL_PINK; + } +} + diff --git a/src/Mobs/NewSheep.h b/src/Mobs/NewSheep.h new file mode 100644 index 000000000..a4925b686 --- /dev/null +++ b/src/Mobs/NewSheep.h @@ -0,0 +1,46 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSheep : + public cNewMonster +{ + typedef cNewMonster super; + +public: + + /** The number is the color of the sheep. + Use E_META_WOOL_* constants for the wool color. + If you type -1, the server will generate a random color + with the GenerateNaturalRandomColor() function. */ + cNewSheep(int a_Color = -1); + + CLASS_PROTODEF(cNewSheep) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + /** Generates a random color for the sheep like the vanilla server. + The percent's where used are from the wiki: http://minecraft.gamepedia.com/Sheep#Breeding */ + static NIBBLETYPE GenerateNaturalRandomColor(void); + + bool IsSheared(void) const { return m_IsSheared; } + void SetSheared(bool a_IsSheared) { m_IsSheared = a_IsSheared; } + + int GetFurColor(void) const { return m_WoolColor; } + void SetFurColor(int a_WoolColor) { m_WoolColor = a_WoolColor; } + +private: + bool m_IsSheared; + int m_WoolColor; + // int m_TimeToStopEating; + +} ; + + + + diff --git a/src/Mobs/NewSilverfish.h b/src/Mobs/NewSilverfish.h new file mode 100644 index 000000000..e056a0547 --- /dev/null +++ b/src/Mobs/NewSilverfish.h @@ -0,0 +1,26 @@ + +#pragma once + +#include "ANewMonster.h" + + + + + +class cNewSilverfish : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewSilverfish(void) : + super("Silverfish", mtSilverfish, "mob.silverfish.hit", "mob.silverfish.kill", 0.3, 0.7) + { + } + + CLASS_PROTODEF(cNewSilverfish) +} ; + + + + diff --git a/src/Mobs/NewSkeleton.cpp b/src/Mobs/NewSkeleton.cpp new file mode 100644 index 000000000..4c9e31e63 --- /dev/null +++ b/src/Mobs/NewSkeleton.cpp @@ -0,0 +1,58 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSkeleton.h" +#include "../World.h" +#include "../Entities/ArrowEntity.h" +#include "ClientHandle.h" + + + + +cNewSkeleton::cNewSkeleton(bool IsWither) : + super("Skeleton", mtSkeleton, "mob.skeleton.hurt", "mob.skeleton.death", 0.6, 1.8), + m_bIsWither(IsWither) +{ +} + + + + + +void cNewSkeleton::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + if (IsWither()) + { + AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_COAL); + cItems RareDrops; + RareDrops.Add(cItem(E_ITEM_HEAD, 1, 1)); + AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel); + } + else + { + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_ARROW); + + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_BONE); + AddRandomArmorDropItem(a_Drops, LootingLevel); + AddRandomWeaponDropItem(a_Drops, LootingLevel); +} + + + + + +void cNewSkeleton::SpawnOn(cClientHandle & a_ClientHandle) +{ + super::SpawnOn(a_ClientHandle); + a_ClientHandle.SendEntityEquipment(*this, 0, cItem(E_ITEM_BOW)); +} + + + + diff --git a/src/Mobs/NewSkeleton.h b/src/Mobs/NewSkeleton.h new file mode 100644 index 000000000..2355a377e --- /dev/null +++ b/src/Mobs/NewSkeleton.h @@ -0,0 +1,33 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSkeleton : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewSkeleton(bool IsWither); + + CLASS_PROTODEF(cNewSkeleton) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override;\ + virtual void SpawnOn(cClientHandle & a_ClientHandle) override; + + bool IsWither(void) const { return m_bIsWither; } + +private: + + bool m_bIsWither; + +} ; + + + + diff --git a/src/Mobs/NewSlime.cpp b/src/Mobs/NewSlime.cpp new file mode 100644 index 000000000..60f0021ab --- /dev/null +++ b/src/Mobs/NewSlime.cpp @@ -0,0 +1,61 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSlime.h" +#include "FastRandom.h" +#include "World.h" + + + + + +cNewSlime::cNewSlime(int a_Size) : + super("Slime", + mtSlime, + Printf("mob.slime.%s", GetSizeName(a_Size).c_str()), + Printf("mob.slime.%s", GetSizeName(a_Size).c_str()), + 0.6 * a_Size, + 0.6 * a_Size + ), + m_Size(a_Size) +{ +} + + + + + +void cNewSlime::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + + // Only slimes with the size 1 can drop slimeballs. + if (m_Size == 1) + { + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SLIMEBALL); + } +} + + + + + +const AString cNewSlime::GetSizeName(int a_Size) const +{ + if (a_Size > 1) + { + return "big"; + } + else + { + return "small"; + } +} + + + + diff --git a/src/Mobs/NewSlime.h b/src/Mobs/NewSlime.h new file mode 100644 index 000000000..458879a76 --- /dev/null +++ b/src/Mobs/NewSlime.h @@ -0,0 +1,39 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSlime : + public cNewMonster +{ + typedef cNewMonster super; + +public: + /** Creates a slime of the specified size; size can be 1, 2 or 4, with 1 is the smallest and 4 is the tallest. */ + cNewSlime(int a_Size); + + CLASS_PROTODEF(cNewSlime) + + // cAggressiveMonster overrides: + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + int GetSize(void) const { return m_Size; } + + /** Returns the text describing the slime's size, as used by the client's resource subsystem for sounds. + Returns either "big" or "small". */ + const AString GetSizeName(int a_Size) const; + +protected: + + /** Size of the slime, with 1 being the smallest. + Vanilla uses sizes 1, 2 and 4 only. */ + int m_Size; +} ; + + + + diff --git a/src/Mobs/NewSnowGolem.cpp b/src/Mobs/NewSnowGolem.cpp new file mode 100644 index 000000000..c7f91b1ce --- /dev/null +++ b/src/Mobs/NewSnowGolem.cpp @@ -0,0 +1,24 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSnowGolem.h" +#include "../World.h" + + + + + +cNewSnowGolem::cNewSnowGolem(void) : + super("SnowGolem", mtSnowGolem, "", "", 0.4, 1.8) +{ +} + + + + + +void cNewSnowGolem::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + UNUSED(a_Killer); + AddRandomDropItem(a_Drops, 0, 15, E_ITEM_SNOWBALL); +} diff --git a/src/Mobs/NewSnowGolem.h b/src/Mobs/NewSnowGolem.h new file mode 100644 index 000000000..3305bf3c2 --- /dev/null +++ b/src/Mobs/NewSnowGolem.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSnowGolem : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewSnowGolem(void); + + CLASS_PROTODEF(cNewSnowGolem) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewSpider.cpp b/src/Mobs/NewSpider.cpp new file mode 100644 index 000000000..56d04c0ae --- /dev/null +++ b/src/Mobs/NewSpider.cpp @@ -0,0 +1,35 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSpider.h" + + + + + +cNewSpider::cNewSpider(void) : + super("Spider", mtSpider, "mob.spider.say", "mob.spider.death", 1.4, 0.9) +{ +} + + + + + +void cNewSpider::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STRING); + if ((a_Killer != NULL) && (a_Killer->IsPlayer() || a_Killer->IsA("cWolf"))) + { + AddRandomUncommonDropItem(a_Drops, 33.0f, E_ITEM_SPIDER_EYE); + } +} + + + + diff --git a/src/Mobs/NewSpider.h b/src/Mobs/NewSpider.h new file mode 100644 index 000000000..f0543d1e1 --- /dev/null +++ b/src/Mobs/NewSpider.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSpider : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewSpider(void); + + CLASS_PROTODEF(cNewSpider) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewSquid.cpp b/src/Mobs/NewSquid.cpp new file mode 100644 index 000000000..40f4ed3c1 --- /dev/null +++ b/src/Mobs/NewSquid.cpp @@ -0,0 +1,33 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewSquid.h" +#include "../Vector3.h" +#include "../Chunk.h" + + + + + +cNewSquid::cNewSquid(void) : + super("Squid", mtSquid, "", "", 0.95, 0.95) +{ +} + + + + + +void cNewSquid::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + // Drops 0-3 Ink Sacs + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 3 + LootingLevel, E_ITEM_DYE, E_META_DYE_BLACK); +} + + + diff --git a/src/Mobs/NewSquid.h b/src/Mobs/NewSquid.h new file mode 100644 index 000000000..203ff7af5 --- /dev/null +++ b/src/Mobs/NewSquid.h @@ -0,0 +1,25 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewSquid : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewSquid(); + + CLASS_PROTODEF(cNewSquid) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + diff --git a/src/Mobs/NewVillager.cpp b/src/Mobs/NewVillager.cpp new file mode 100644 index 000000000..844d65b61 --- /dev/null +++ b/src/Mobs/NewVillager.cpp @@ -0,0 +1,19 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewVillager.h" +#include "../World.h" +#include "../BlockArea.h" +#include "../Blocks/BlockHandler.h" +#include "../BlockInServerPluginInterface.h" + + + + + +cNewVillager::cNewVillager(eVillagerType VillagerType) : + super("Villager", mtVillager, "", "", 0.6, 1.8), + m_Type(VillagerType) +{ +} + diff --git a/src/Mobs/NewVillager.h b/src/Mobs/NewVillager.h new file mode 100644 index 000000000..fb543d90c --- /dev/null +++ b/src/Mobs/NewVillager.h @@ -0,0 +1,43 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewVillager : + public cNewMonster +{ + typedef cNewMonster super; + +public: + + enum eVillagerType + { + vtFarmer = 0, + vtLibrarian = 1, + vtPriest = 2, + vtBlacksmith = 3, + vtButcher = 4, + vtGeneric = 5, + vtMax + } ; + + cNewVillager(eVillagerType VillagerType); + + CLASS_PROTODEF(cNewVillager) + + // Get and set functions. + int GetVilType(void) const { return m_Type; } + +private: + + int m_Type; + +} ; + + + + diff --git a/src/Mobs/NewWitch.cpp b/src/Mobs/NewWitch.cpp new file mode 100644 index 000000000..34036fe4b --- /dev/null +++ b/src/Mobs/NewWitch.cpp @@ -0,0 +1,47 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewWitch.h" + + + + + +cNewWitch::cNewWitch(void) : + super("Witch", mtWitch, "", "", 0.6, 1.8) +{ +} + + + + + +void cNewWitch::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + MTRand r1; + int DropTypeCount = (r1.randInt() % 3) + 1; + for (int i = 0; i < DropTypeCount; i++) + { + int DropType = r1.randInt() % 7; + switch (DropType) + { + case 0: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GLASS_BOTTLE); break; + case 1: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GLOWSTONE_DUST); break; + case 2: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_GUNPOWDER); break; + case 3: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_REDSTONE_DUST); break; + case 4: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SPIDER_EYE); break; + case 5: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_STICK); break; + case 6: AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_SUGAR); break; + } + } + AddRandomWeaponDropItem(a_Drops, LootingLevel); +} + + + + diff --git a/src/Mobs/NewWitch.h b/src/Mobs/NewWitch.h new file mode 100644 index 000000000..02d9cc3d0 --- /dev/null +++ b/src/Mobs/NewWitch.h @@ -0,0 +1,28 @@ + +#pragma once + +#include "NewMonster.h" +#include "../MersenneTwister.h" + + + + + +class cNewWitch : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewWitch(); + + CLASS_PROTODEF(cNewWitch) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsAngry(void) const {return false; } +} ; + + + + diff --git a/src/Mobs/NewWither.cpp b/src/Mobs/NewWither.cpp new file mode 100644 index 000000000..c4f26f1da --- /dev/null +++ b/src/Mobs/NewWither.cpp @@ -0,0 +1,42 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewWither.h" + +#include "../World.h" +#include "../Entities/Player.h" + + + + + +cNewWither::cNewWither(void) : + super("Wither", mtWither, "mob.wither.hurt", "mob.wither.death", 0.9, 4.0) +{ + SetMaxHealth(300); +} + + + + + +bool cNewWither::Initialize(cWorld & a_World) +{ + // Set health before BroadcastSpawnEntity() + SetHealth(GetMaxHealth() / 3); + + return super::Initialize(a_World); +} + + + + + +void cNewWither::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + AddRandomDropItem(a_Drops, 1, 1, E_ITEM_NETHER_STAR); +} + + + + diff --git a/src/Mobs/NewWither.h b/src/Mobs/NewWither.h new file mode 100644 index 000000000..91f824016 --- /dev/null +++ b/src/Mobs/NewWither.h @@ -0,0 +1,31 @@ + +#pragma once + +#include "NewMonster.h" + + + + + +class cNewWither : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewWither(void); + + CLASS_PROTODEF(cNewWither) + + /** Returns whether the wither is invulnerable to arrows. */ + bool IsArmored(void) const; + + // cEntity overrides + virtual bool Initialize(cWorld & a_World) override; + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + +} ; + + + + diff --git a/src/Mobs/NewWolf.cpp b/src/Mobs/NewWolf.cpp new file mode 100644 index 000000000..4e95bf6e8 --- /dev/null +++ b/src/Mobs/NewWolf.cpp @@ -0,0 +1,24 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewWolf.h" +#include "../World.h" +#include "../Entities/Player.h" +#include "../Items/ItemHandler.h" + + + + + +cNewWolf::cNewWolf(void) : + super("Wolf", mtWolf, "mob.wolf.hurt", "mob.wolf.death", 0.6, 0.8), + m_IsSitting(false), + m_IsBegging(false), + m_IsAngry(false), + m_CollarColor(14) +{ +} + + + + diff --git a/src/Mobs/NewWolf.h b/src/Mobs/NewWolf.h new file mode 100644 index 000000000..6df63d795 --- /dev/null +++ b/src/Mobs/NewWolf.h @@ -0,0 +1,43 @@ + +#pragma once + +#include "NewMonster.h" +#include "../Entities/Entity.h" + + + + + +class cNewWolf : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewWolf(void); + + CLASS_PROTODEF(cNewWolf) + + // Get functions + bool IsSitting (void) const { return m_IsSitting; } + bool IsBegging (void) const { return m_IsBegging; } + bool IsAngry (void) const { return m_IsAngry; } + int GetCollarColor(void) const { return m_CollarColor; } + + // Set functions + void SetIsSitting (bool a_IsSitting) { m_IsSitting = a_IsSitting; } + void SetIsBegging (bool a_IsBegging) { m_IsBegging = a_IsBegging; } + void SetIsAngry (bool a_IsAngry) { m_IsAngry = a_IsAngry; } + void SetCollarColor(int a_CollarColor) { m_CollarColor = a_CollarColor; } + +protected: + + bool m_IsSitting; + bool m_IsBegging; + bool m_IsAngry; + int m_CollarColor; +} ; + + + + diff --git a/src/Mobs/NewZombie.cpp b/src/Mobs/NewZombie.cpp new file mode 100644 index 000000000..d37ea22bc --- /dev/null +++ b/src/Mobs/NewZombie.cpp @@ -0,0 +1,42 @@ + +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewZombie.h" +#include "../World.h" +#include "../LineBlockTracer.h" + + + + + +cNewZombie::cNewZombie(bool a_IsVillagerZombie) : + super("Zombie", mtZombie, "mob.zombie.hurt", "mob.zombie.death", 0.6, 1.8), + m_IsVillagerZombie(a_IsVillagerZombie), + m_IsConverting(false) +{ +} + + + + + +void cNewZombie::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 2 + LootingLevel, E_ITEM_ROTTEN_FLESH); + cItems RareDrops; + RareDrops.Add(cItem(E_ITEM_IRON)); + RareDrops.Add(cItem(E_ITEM_CARROT)); + RareDrops.Add(cItem(E_ITEM_POTATO)); + AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel); + AddRandomArmorDropItem(a_Drops, LootingLevel); + AddRandomWeaponDropItem(a_Drops, LootingLevel); +} + + + + diff --git a/src/Mobs/NewZombie.h b/src/Mobs/NewZombie.h new file mode 100644 index 000000000..7388711c6 --- /dev/null +++ b/src/Mobs/NewZombie.h @@ -0,0 +1,33 @@ +#pragma once + +#include "NewMonster.h" + + + + + +class cNewZombie : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewZombie(bool a_IsVillagerZombie); + + CLASS_PROTODEF(cNewZombie) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; + + bool IsVillagerZombie(void) const { return m_IsVillagerZombie; } + bool IsConverting (void) const { return m_IsConverting; } + +private: + + bool m_IsVillagerZombie; + bool m_IsConverting; + +} ; + + + + diff --git a/src/Mobs/NewZombiePigman.cpp b/src/Mobs/NewZombiePigman.cpp new file mode 100644 index 000000000..e0a491805 --- /dev/null +++ b/src/Mobs/NewZombiePigman.cpp @@ -0,0 +1,38 @@ +#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules + +#include "NewZombiePigman.h" +#include "../World.h" + + + + + +cNewZombiePigman::cNewZombiePigman(void) : + super("ZombiePigman", mtZombiePigman, "mob.zombiepig.zpighurt", "mob.zombiepig.zpigdeath", 0.6, 1.8) +{ +} + + + + + +void cNewZombiePigman::GetDrops(cItems & a_Drops, cEntity * a_Killer) +{ + int LootingLevel = 0; + if (a_Killer != NULL) + { + LootingLevel = a_Killer->GetEquippedWeapon().m_Enchantments.GetLevel(cEnchantments::enchLooting); + } + AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_ROTTEN_FLESH); + AddRandomDropItem(a_Drops, 0, 1 + LootingLevel, E_ITEM_GOLD_NUGGET); + + cItems RareDrops; + RareDrops.Add(cItem(E_ITEM_GOLD)); + AddRandomRareDropItem(a_Drops, RareDrops, LootingLevel); + AddRandomArmorDropItem(a_Drops, LootingLevel); + AddRandomWeaponDropItem(a_Drops, LootingLevel); +} + + + + diff --git a/src/Mobs/NewZombiePigman.h b/src/Mobs/NewZombiePigman.h new file mode 100644 index 000000000..13a67f4b0 --- /dev/null +++ b/src/Mobs/NewZombiePigman.h @@ -0,0 +1,24 @@ +#pragma once + +#include "NewMonster.h" + + + + + +class cNewZombiePigman : + public cNewMonster +{ + typedef cNewMonster super; + +public: + cNewZombiePigman(void); + + CLASS_PROTODEF(cNewZombiePigman) + + virtual void GetDrops(cItems & a_Drops, cEntity * a_Killer = NULL) override; +} ; + + + + |