server/data/python/scene0_10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scene 0.10\n",
    "\n",
    "![Hola en Minecraft](https://user-images.githubusercontent.com/209533/79888667-512ba200-83fd-11ea-92a1-c6c401d72d40.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already up-to-date: mcthings in /opt/conda/lib/python3.7/site-packages (0.6.5)\r\n",
      "Requirement already satisfied, skipping upgrade: minecraftstuff in /opt/conda/lib/python3.7/site-packages (from mcthings) (1.0.1)\r\n",
      "Requirement already satisfied, skipping upgrade: mcpi in /opt/conda/lib/python3.7/site-packages (from mcthings) (1.1.0)\r\n"
     ]
    }
   ],
   "source": [
    "# Install McThings to create the Scene\n",
    "\n",
    "!pip install mcthings --upgrade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import definition of blocks\n",
    "import mcpi.block\n",
    "\n",
    "# Import Vec3 for defining positions\n",
    "from mcpi.vec3 import Vec3\n",
    "\n",
    "# Be sure to use the last version\n",
    "import importlib\n",
    "import mcthings\n",
    "importlib.reload(mcthings)\n",
    "\n",
    "# Import Scene and Server\n",
    "from mcthings.scene import Scene\n",
    "from mcthings.server import Server\n",
    "\n",
    "# Import the Things used in the Scene\n",
    "from mcthings.bridge import Bridge\n",
    "from mcthings.building import Building\n",
    "from mcthings.fence import Fence\n",
    "from mcthings.line import Line\n",
    "from mcthings.pyramid import Pyramid\n",
    "from mcthings.pyramid import PyramidHollow\n",
    "from mcthings.river import River\n",
    "from mcthings.sphere import Sphere\n",
    "from mcthings.sphere import SphereHollow\n",
    "from mcthings.town import Town"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Connect to the Minecraft server and send a testing message to chat\n",
    "\n",
    "MC_SEVER_HOST = \"minecraft\"\n",
    "MC_SEVER_PORT = 4711\n",
    "\n",
    "server = Server(MC_SEVER_HOST, MC_SEVER_PORT)\n",
    "\n",
    "server.mc.postToChat(\"Building a Scene for 0.10 release\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the initial position to create the scene\n",
    "\n",
    "BUILDER_NAME = \"ElasticExplorer\"\n",
    "\n",
    "pos = server.mc.entity.getTilePos(server.mc.getPlayerEntityId(BUILDER_NAME))\n",
    "pos.x += 1\n",
    "\n",
    "server.mc.postToChat(\"Building the Scene at %s %s %s \" % (\n",
    "    pos.x, pos.y, pos.z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The order in which the scene will be built\n",
    "\n",
    "* Create the river **OK**\n",
    "* Create the bridges **OK**\n",
    "* Create lines at both side of the river **OK**\n",
    "* Create the houses along the river **OK**\n",
    "* Create lines going to the main areas and the things in each area\n",
    "  * Temple (pyramid) **OK**\n",
    "  * Jail (fenced town) **OK**\n",
    "  * buildings (group of buildings) **OK**\n",
    "  * stadium (sphere) **OK**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# River\n",
    "\n",
    "river_width = 10\n",
    "river = River(pos)\n",
    "river.width = river_width\n",
    "river.length = 100\n",
    "river.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bridges are created for crossing the river\n",
    "# Position them and 1/4 and 3/4 of the length of the river\n",
    "\n",
    "bridge_start = Bridge(Vec3(pos.x-1, pos.y, pos.z + (river.length*(1/4))))\n",
    "bridge_start.height = 3\n",
    "bridge_start.large = river.width + 2\n",
    "bridge_start.width = 2\n",
    "bridge_start.block = mcpi.block.WOOD\n",
    "bridge_start.build()\n",
    "\n",
    "bridge_end   = Bridge(Vec3(pos.x-1, pos.y, pos.z + (river.length*(3/4))))\n",
    "bridge_end.height = 3\n",
    "bridge_end.large = river.width + 2\n",
    "bridge_end.width = 2\n",
    "bridge_end.block = mcpi.block.WOOD\n",
    "bridge_end.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lines (paths) at both sides of the river\n",
    "\n",
    "line_width = 2\n",
    "line_right = Line(Vec3(pos.x - (3 + line_width), pos.y, pos.z))\n",
    "line_right.block = mcpi.block.SAND\n",
    "line_right.length = river.length\n",
    "line_right.width = line_width\n",
    "line_right.build()\n",
    "\n",
    "line_left = Line(Vec3(pos.x + river.width + 3, pos.y, pos.z))\n",
    "line_left.block = mcpi.block.SAND\n",
    "line_left.length = river.length\n",
    "line_left.width = line_width\n",
    "line_left.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the houses along the river\n",
    "\n",
    "house_width = 5\n",
    "house_length = 5\n",
    "houses = 4 * 3 + 1\n",
    "\n",
    "p = line_right.position\n",
    "# 2 line width \n",
    "town_right = Town(Vec3(p.x - 2, p.y, p.z))\n",
    "town_right.house_width = house_width\n",
    "town_right.house_length = house_length\n",
    "town_right.house_mirror = True\n",
    "town_right.houses = houses\n",
    "town_right.build()\n",
    "\n",
    "p = line_left.position\n",
    "# 2 line width \n",
    "town_left = Town(Vec3(p.x + (2 + 1), p.y, p.z))\n",
    "town_left.house_width = house_width\n",
    "town_left.house_length = house_length\n",
    "town_left.houses = houses\n",
    "town_left.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Temple (Pyramid)\n",
    "\n",
    "temple_far = 30  # closer than the jail\n",
    "\n",
    "# First the path from the town to the temple\n",
    "p = line_right.position\n",
    "p_z = p.z + house_length + 1\n",
    "line_temple = Line(Vec3(p.x, p.y, p_z))\n",
    "line_temple.block = mcpi.block.SAND\n",
    "line_temple.width = -temple_far\n",
    "line_temple.length = 2\n",
    "line_temple.build()\n",
    "# And now the temple\n",
    "temple_height = 15\n",
    "temple_width = 2 * temple_height - 1\n",
    "\n",
    "p = line_temple.end_position\n",
    "p_z = p.z - temple_width/2\n",
    "p_x = p.x - temple_width\n",
    "temple = PyramidHollow(Vec3(p_x, p.y, p_z))\n",
    "temple.height = temple_height\n",
    "temple.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Jail (Fenced town)\n",
    "\n",
    "jail_far = 50\n",
    "fence_space = 5\n",
    "\n",
    "# First the path from the town to the jail\n",
    "p = line_left.position\n",
    "p_z = p.z + house_length + 1\n",
    "line_jail = Line(Vec3(p.x, p.y, p_z))\n",
    "line_jail.block = mcpi.block.SAND\n",
    "line_jail.width = +jail_far\n",
    "line_jail.length = 2\n",
    "line_jail.build()\n",
    "\n",
    "# The jail town\n",
    "house_jail_width = 10\n",
    "p = line_jail.end_position\n",
    "p_z = p.z - (2 * house_jail_width)\n",
    "p_x = p.x\n",
    "town_jail = Town(Vec3(p_x, p.y, p_z))\n",
    "town_jail.space = 1\n",
    "town_jail.house_width = house_jail_width\n",
    "town_jail.block = mcpi.block.STONE\n",
    "town_jail.build()\n",
    "\n",
    "fence_jail = Fence(None)\n",
    "fence_jail.thing = town_jail\n",
    "fence_jail.block = mcpi.block.BEDROCK\n",
    "fence_jail.fence_space = fence_space\n",
    "fence_jail.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# buildings (group of buildings)\n",
    "\n",
    "building_far = 40\n",
    "\n",
    "# First the path from the town to the buildings\n",
    "p = line_right.end_position\n",
    "p_z = p.z - (house_length + 1)\n",
    "line_building = Line(Vec3(p.x, p.y, p_z))\n",
    "line_building.block = mcpi.block.SAND\n",
    "line_building.width = -building_far\n",
    "line_building.length = 2\n",
    "line_building.build()\n",
    "\n",
    "# Now the buildings\n",
    "building_width = 10\n",
    "p = line_building.end_position\n",
    "building1 = Building(Vec3(p.x, p.y, p.z - building_width/2))\n",
    "building1.width = building_width\n",
    "building1.house_mirror = True\n",
    "building1.build()\n",
    "\n",
    "p_z = p.z - 2* building_width\n",
    "building2 = Building(Vec3(p.x, p.y, p_z))\n",
    "building2.width = building_width\n",
    "building2.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the Stadium (sphere)\n",
    "stadium_far = 50\n",
    "\n",
    "# First the path from the town to the stadium\n",
    "p = line_left.end_position\n",
    "p_z = p.z - (house_length + 1)\n",
    "line_stadium = Line(Vec3(p.x, p.y, p_z))\n",
    "line_stadium.block = mcpi.block.SAND\n",
    "line_stadium.width = +stadium_far\n",
    "line_stadium.length = 2\n",
    "line_stadium.build()\n",
    "\n",
    "stadium = SphereHollow(line_stadium.end_position)\n",
    "stadium.radius = 15\n",
    "stadium.height = 14\n",
    "stadium.block = mcpi.block.IRON_BLOCK\n",
    "stadium.build()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "Scene.save('scene0_10.mct')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Final Scene](img/scene0_10.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A cell to add/remove things during the creation for fixing them\n",
    "\n",
    "# building.unbuild()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TODO\n",
    "\n",
    "* Remove path inside the jail\n",
    "* The sphere have a portal to go inside\n",
    "* The must have a portal to go inside\n",
    "* Add a railway around the monuments"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}