mummy.lua

   1 local S = minetest.get_translator("tsm_pyramids")
   2
   3 local mummy_walk_limit = 1
   4 local mummy_chillaxin_speed = 1
   5 local mummy_animation_speed = 10
   6 -- Note: This is currently broken due to a bug in Irrlicht, leave at 0
   7 local mummy_animation_blend = 0
   8
   9 -- Default player appearance
  10 local mummy_mesh = "tsm_pyramids_mummy.x"
  11 local mummy_texture = {"tsm_pyramids_mummy.png"}
  12 local mummy_hp = 20
  13 local mummy_drop = "default:papyrus"
  14
  15 local sound_normal = "mummy"
  16 local sound_hit = "mummy_hurt"
  17 local sound_dead = "mummy_death"
  18
  19 local spawner_range = 17
  20 local spawner_max_mobs = 6
  21
  22 local function get_animations()
  23         return {
  24                 stand_START = 74,
  25                 stand_END = 74,
  26                 sit_START = 81,
  27                 sit_END = 160,
  28                 lay_START = 162,
  29                 lay_END = 166,
  30                 walk_START = 74,
  31                 walk_END = 105,
  32                 mine_START = 74,
  33                 mine_END = 105,
  34                 walk_mine_START = 74,
  35                 walk_mine_END = 105
  36         }
  37 end
  38
  39 local npc_model = {}
  40 local npc_anim = {}
  41 local npc_sneak = {}
  42 local ANIM_STAND = 1
  43 local ANIM_SIT = 2
  44 local ANIM_LAY = 3
  45 local ANIM_WALK  = 4
  46 local ANIM_WALK_MINE = 5
  47 local ANIM_MINE = 6
  48
  49 local function hit(self)
  50         local prop = {
  51                 mesh = mummy_mesh,
  52                 textures = {"tsm_pyramids_mummy.png^tsm_pyramids_hit.png"},
  53         }
  54         self.object:set_properties(prop)
  55         minetest.after(0.4, function()
  56                local prop = {textures = mummy_texture,}
  57                 self.object:set_properties(prop)
  58         end)
  59 end
  60
  61 local function mummy_update_visuals_def(self)
  62         npc_anim = 0 -- Animation will be set further below immediately
  63         local prop = {
  64                 mesh = mummy_mesh,
  65                 textures = mummy_texture,
  66         }
  67         self.object:set_properties(prop)
  68 end
  69
  70 local MUMMY_DEF = {
  71         physical = true,
  72         collisionbox = {-0.4, -0.01, -0.4, 0.4, 1.9, 0.4},
  73         visual = "mesh",
  74         visual_size = {x=8,y=8},
  75         mesh = mummy_mesh,
  76         textures = mummy_texture,
  77         makes_footstep_sound = true,
  78         npc_anim = 0,
  79         timer = 0,
  80         turn_timer = 0,
  81         vec = 0,
  82         yaw = 0,
  83         yawwer = 0,
  84         state = 1,
  85         jump_timer = 0,
  86         punch_timer = 0,
  87         sound_timer = 0,
  88         envdmg_timer = 0,
  89         attacker = "",
  90         attacking_timer = 0,
  91         mob_name = "mummy"
  92 }
  93
  94 local spawner_DEF = {
  95         hp_max = 1,
  96         physical = true,
  97         collisionbox = {0,0,0,0,0,0},
  98         visual = "mesh",
  99         visual_size = {x=3.3,y=3.3},
 100         mesh = mummy_mesh,
 101         textures = mummy_texture,
 102         makes_footstep_sound = false,
 103         timer = 0,
 104         automatic_rotate = math.pi * 2.9,
 105         m_name = "dummy"
 106 }
 107
 108 spawner_DEF.on_activate = function(self)
 109         mummy_update_visuals_def(self)
 110         self.object:set_velocity({x=0, y=0, z=0})
 111         self.object:set_acceleration({x=0, y=0, z=0})
 112         self.object:set_armor_groups({immortal=1})
 113
 114 end
 115
 116 spawner_DEF.on_step = function(self, dtime)
 117         self.timer = self.timer + 0.01
 118         local n = minetest.get_node_or_nil(self.object:get_pos())
 119         if self.timer > 1 then
 120                 if n and n.name and n.name ~= "tsm_pyramids:spawner_mummy" then
 121                         self.object:remove()
 122                 end
 123         end
 124 end
 125
 126 spawner_DEF.on_punch = function(self, hitter)
 127
 128 end
 129
 130 MUMMY_DEF.on_activate = function(self)
 131         mummy_update_visuals_def(self)
 132         self.anim = get_animations()
 133         self.object:set_animation({x=self.anim.stand_START,y=self.anim.stand_END}, mummy_animation_speed, mummy_animation_blend)
 134         self.npc_anim = ANIM_STAND
 135         self.object:set_acceleration({x=0,y=-20,z=0})--20
 136         self.state = 1
 137         self.object:set_hp(mummy_hp)
 138         self.object:set_armor_groups({fleshy=130})
 139 end
 140
 141 MUMMY_DEF.on_punch = function(self, puncher, time_from_last_punch, tool_capabilities, dir)
 142
 143         self.attacker = puncher
 144
 145         if puncher ~= nil then
 146                 local sound = sound_hit
 147                 if self.object:get_hp() == 0 then sound = sound_dead end
 148                 minetest.sound_play(sound, {to_player = puncher:get_player_name(), loop = false, gain = 0.3})
 149                 if time_from_last_punch >= 0.45 then
 150                         hit(self)
 151                         self.direction = {x=self.object:get_velocity().x, y=self.object:get_velocity().y, z=self.object:get_velocity().z}
 152                         self.punch_timer = 0
 153                         self.object:set_velocity({x=dir.x*mummy_chillaxin_speed,y=5,z=dir.z*mummy_chillaxin_speed})
 154                         if self.state == 1 then
 155                                 self.state = 8
 156                         elseif self.state >= 2 then
 157                                 self.state = 9
 158                         end
 159                 end
 160         end
 161
 162         if self.object:get_hp() == 0 then
 163             local obj = minetest.add_item(self.object:get_pos(), mummy_drop.." "..math.random(0,3))
 164         end
 165 end
 166
 167         local cnt1 = 0
 168         local cnt2 = 0
 169
 170 MUMMY_DEF.on_step = function(self, dtime)
 171         self.timer = self.timer + 0.01
 172         self.turn_timer = self.turn_timer + 0.01
 173         self.jump_timer = self.jump_timer + 0.01
 174         self.punch_timer = self.punch_timer + 0.01
 175         self.attacking_timer = self.attacking_timer + 0.01
 176         self.sound_timer = self.sound_timer + dtime + 0.01
 177
 178         local current_pos = self.object:get_pos()
 179         local current_node = minetest.get_node(current_pos)
 180         if self.time_passed == nil then
 181                 self.time_passed = 0
 182         end
 183
 184         if self.object:get_hp() == 0 then
 185                 minetest.sound_play(sound_dead, {pos = current_pos, max_hear_distance = 10 , gain = 0.3})
 186                 self.object:remove()
 187         end
 188         local def = minetest.registered_nodes[current_node.name]
 189         local dps = def.damage_per_second
 190         local dmg = 0
 191         if dps ~= nil and dps > 0 then
 192                 dmg = dps
 193         end
 194         -- Damage from node
 195         if dmg < 4 and (minetest.get_item_group(current_node.name, "water") ~= 0 or minetest.get_item_group(current_node.name, "lava") ~= 0) then
 196                 dmg = 4
 197         end
 198         -- Damage by suffocation
 199         if (def.walkable == nil or def.walkable == true)
 200         and (def.drowning == nil or def.drowning == 0)
 201         and (def.damage_per_second == nil or def.damage_per_second <= 0)
 202         and (def.collision_box == nil or def.collision_box.type == "regular")
 203         and (def.node_box == nil or def.node_box.type == "regular")
 204         and (def.groups and def.groups.disable_suffocation ~= 1) then
 205                 dmg = dmg + 1
 206         end
 207         self.envdmg_timer = self.envdmg_timer + dtime
 208         if dmg > 0 then
 209                 if self.envdmg_timer >= 1 then
 210                         self.envdmg_timer = 0
 211                         self.object:set_hp(self.object:get_hp()-dmg)
 212                         hit(self)
 213                         self.sound_timer = 0
 214                         minetest.sound_play(sound_hit, {pos = current_pos, max_hear_distance = 10, gain = 0.3})
 215                 end
 216          else
 217                 self.time_passed = 0
 218          end
 219
 220         --update moving state every 1 or 2 seconds
 221         if self.state < 3 then
 222                 if self.timer > math.random(1,2) then
 223                         if self.attacker == "" then
 224                                 self.state = math.random(1,2)
 225                         else self.state = 1 end
 226                         self.timer = 0
 227                 end
 228         end
 229
 230         --play sound
 231         if self.sound_timer > math.random(5,35) then
 232                 minetest.sound_play(sound_normal, {pos = current_pos, max_hear_distance = 10, gain = 0.2})
 233                 self.sound_timer = 0
 234         end
 235
 236         --after punched
 237         if self.state >= 8 then
 238                 if self.punch_timer > 0.15 then
 239                         if self.state == 9 then
 240                                 self.object:set_velocity({x=self.direction.x*mummy_chillaxin_speed,y=-20,z=self.direction.z*mummy_chillaxin_speed})
 241                                 self.state = 2
 242                         elseif self.state == 8 then
 243                                 self.object:set_velocity({x=0,y=-20,z=0})
 244                                 self.state = 1
 245                         end
 246                 end
 247         end
 248
 249         --STANDING
 250         if self.state == 1 then
 251                 self.yawwer = true
 252                 self.attacker = ""
 253                 for  _,object in ipairs(minetest.get_objects_inside_radius(self.object:get_pos(), 4)) do
 254                         if object:is_player() then
 255                                 self.yawwer = false
 256                                 local NPC = self.object:get_pos()
 257                                 local PLAYER = object:get_pos()
 258                                 self.vec = {x=PLAYER.x-NPC.x, y=PLAYER.y-NPC.y, z=PLAYER.z-NPC.z}
 259                                 self.yaw = math.atan(self.vec.z/self.vec.x)+math.pi^2
 260                                 if PLAYER.x > NPC.x then
 261                                         self.yaw = self.yaw + math.pi
 262                                 end
 263                                 self.yaw = self.yaw - 2
 264                                 self.object:set_yaw(self.yaw)
 265                                 self.attacker = object
 266                         end
 267                 end
 268
 269                 if self.attacker == "" and self.turn_timer > math.random(1,4) then
 270                         self.yaw = 360 * math.random()
 271                         self.object:set_yaw(self.yaw)
 272                         self.turn_timer = 0
 273                         self.direction = {x = math.sin(self.yaw)*-1, y = -20, z = math.cos(self.yaw)}
 274                 end
 275                 self.object:set_velocity({x=0,y=self.object:get_velocity().y,z=0})
 276                 if self.npc_anim ~= ANIM_STAND then
 277                         self.anim = get_animations()
 278                         self.object:set_animation({x=self.anim.stand_START,y=self.anim.stand_END}, mummy_animation_speed, mummy_animation_blend)
 279                         self.npc_anim = ANIM_STAND
 280                 end
 281                 if self.attacker ~= "" then
 282                         self.direction = {x = math.sin(self.yaw)*-1, y = -20, z = math.cos(self.yaw)}
 283                         self.state = 2
 284                 end
 285         end
 286         --WALKING
 287         if self.state == 2 then
 288
 289                 if self.direction ~= nil then
 290                         self.object:set_velocity({x=self.direction.x*mummy_chillaxin_speed,y=self.object:get_velocity().y,z=self.direction.z*mummy_chillaxin_speed})
 291                 end
 292                 if self.turn_timer > math.random(1,4) and not self.attacker then
 293                         self.yaw = 360 * math.random()
 294                         self.object:set_yaw(self.yaw)
 295                         self.turn_timer = 0
 296                         self.direction = {x = math.sin(self.yaw)*-1, y = -20, z = math.cos(self.yaw)}
 297                 end
 298                 if self.npc_anim ~= ANIM_WALK then
 299                         self.anim = get_animations()
 300                         self.object:set_animation({x=self.anim.walk_START,y=self.anim.walk_END}, mummy_animation_speed, mummy_animation_blend)
 301                         self.npc_anim = ANIM_WALK
 302                 end
 303
 304                 if self.attacker ~= "" and minetest.settings:get_bool("enable_damage") then
 305                         local s = self.object:get_pos()
 306                         local p = self.attacker:get_pos()
 307                         if (s ~= nil and p ~= nil) then
 308                                 local dist = ((p.x-s.x)^2 + (p.y-s.y)^2 + (p.z-s.z)^2)^0.5
 309
 310                                 if dist < 2 and self.attacking_timer > 0.6 then
 311                                 self.attacker:punch(self.object, 1.0,  {
 312                                         full_punch_interval=1.0,
 313                                         damage_groups = {fleshy=1}
 314                                 })
 315                                         self.attacking_timer = 0
 316                                 end
 317                         end
 318                 end
 319         end
 320 end
 321
 322 minetest.register_entity("tsm_pyramids:mummy", MUMMY_DEF)
 323 minetest.register_entity("tsm_pyramids:mummy_spawner", spawner_DEF)
 324
 325
 326 --spawn-egg/spawner
 327
 328 minetest.register_craftitem("tsm_pyramids:spawn_egg", {
 329         description = S("Mummy Spawn Egg"),
 330         _doc_items_longdesc = S("Can be used to create a hostile mummy."),
 331         _doc_items_usagehelp = S("Place the egg to create a mummy on this spot. Careful, it will probably attack immediately!"),
 332         inventory_image = "tsm_pyramids_mummy_egg.png",
 333         liquids_pointable = false,
 334         stack_max = 99,
 335         on_place = function(itemstack, placer, pointed_thing)
 336                 if pointed_thing.type == "node" then
 337                         minetest.add_entity(pointed_thing.above,"tsm_pyramids:mummy")
 338                         if not minetest.settings:get_bool("creative_mode") then itemstack:take_item() end
 339                         return itemstack
 340                 end
 341         end,
 342
 343 })
 344
 345 function tsm_pyramids.spawn_mummy (pos, number)
 346         local node = minetest.get_node(pos)
 347         if node.name ~= "air" then
 348                 return
 349         end
 350         for _=1, number do
 351                 minetest.add_entity(pos,"tsm_pyramids:mummy")
 352         end
 353 end
 354
 355 local spawnersounds
 356 if default.node_sound_metal_defaults then
 357         spawnersounds = default.node_sound_metal_defaults()
 358 else
 359         spawnersounds = default.node_sound_stone_defaults()
 360 end
 361
 362 minetest.register_node("tsm_pyramids:spawner_mummy", {
 363         description = S("Mummy Spawner"),
 364         _doc_items_longdesc = S("A mummy spawner causes hostile mummies to appear in its vicinity as long it exists."),
 365         paramtype = "light",
 366         tiles = {"tsm_pyramids_spawner.png"},
 367         is_ground_content = false,
 368         drawtype = "allfaces",
 369         groups = {cracky=1,level=1},
 370         drop = "",
 371         on_construct = function(pos)
 372                 pos.y = pos.y - 0.28
 373                 minetest.add_entity(pos,"tsm_pyramids:mummy_spawner")
 374         end,
 375         on_destruct = function(pos)
 376                 for  _,obj in ipairs(minetest.get_objects_inside_radius(pos, 1)) do
 377                         if not obj:is_player() then
 378                                 if obj ~= nil and obj:get_luaentity().m_name == "dummy" then
 379                                         obj:remove()
 380                                 end
 381                         end
 382                 end
 383         end,
 384         sounds = spawnersounds,
 385 })
 386 if not minetest.settings:get_bool("only_peaceful_mobs") then
 387         minetest.register_abm({
 388                 nodenames = {"tsm_pyramids:spawner_mummy"},
 389                 interval = 2.0,
 390                 chance = 20,
 391                 action = function(pos, node, active_object_count, active_object_count_wider)
 392                         local player_near = false
 393                         local mobs = 0
 394                         for  _,obj in ipairs(minetest.get_objects_inside_radius(pos, spawner_range)) do
 395                                 if obj:is_player() then
 396                                         player_near = true
 397                                 else
 398                                         if obj:get_luaentity() and obj:get_luaentity().mob_name == "mummy" then
 399                                                 mobs = mobs + 1
 400                                         end
 401                                 end
 402                         end
 403                         if player_near then
 404                                 if mobs < spawner_max_mobs then
 405                                         pos.x = pos.x+1
 406                                         local p = minetest.find_node_near(pos, 5, {"air"})
 407                                         local p2 = {x=pos.x, y=pos.y+1, z=pos.z}
 408                                         local n2 = minetest.get_node(p2)
 409                                         if n2.name == "air" then
 410                                                 tsm_pyramids.spawn_mummy(p, 1)
 411                                         end
 412                                 end
 413                         end
 414                 end
 415         })
 416 end
 417
 418 if minetest.get_modpath("awards") then
 419         awards.register_achievement("tsm_pyramids_no_mummy_spawner", {
 420                 title = S("No more mummies!"),
 421                 description = S("Destroy a mummy spawner by digging."),
 422                 secret = true,
 423                 icon = "tsm_pyramids_spawner.png",
 424                 trigger = {
 425                         type = "dig",
 426                         node = "tsm_pyramids:spawner_mummy",
 427                         target = 1
 428                 }
 429         })
 430 end