diff --git a/assets/tinker/lang/de_DE.xml b/assets/tinker/lang/de_DE.xml index 24385669..3369b53b 100644 --- a/assets/tinker/lang/de_DE.xml +++ b/assets/tinker/lang/de_DE.xml @@ -3,7 +3,7 @@ TConstuct Werkzeuge TConstruct Materialien - TConstruct Bl\u00f6cke + TConstruct Blöcke Werkzeugstation Werkzeugesse @@ -23,14 +23,14 @@ Werkzeugesse Trockenregal Schleimiger Matsch - M\u00f6rtel + Mörtel Schleimiger Matsch (blau) Friedhoferde Gesegnete Erde Netherstein-Schlacke - Cobaltit - Ardit + Cobalterz + Arditerz Kupfererz Zinnerz Aluminiumerz @@ -51,19 +51,19 @@ Kobaltkies Rauer Braunstein - Raue braune Stra\u00dfe + Raue braune Straße Braunstein Brauner Ziegel - Braune Stra\u00dfe - Sch\u00f6ner Braunstein + Braune Straße + Schöner Braunstein Ziselierter Braustein Raue Braunsteinstufe - Braune Stra\u00dfenstufe + Braune Straßenstufe Braune Stufe Braune Ziegelstufe - Braune Stra\u00dfenstufe - Sch\u00f6ne braune Stufe + Braune Straßenstufe + Schöne braune Stufe Ziselierte Braunsteinstufe Obsidianziegel @@ -81,22 +81,22 @@ Enderziegel Obsidianziegel - Sch\u00f6ner Obsidianziegel - Sch\u00f6ner Sandsteinziegel - Sch\u00f6ner Nethersteinziegel - Sch\u00f6ner Eisenziegel - Sch\u00f6ner Goldziegel - Sch\u00f6ner Diamantziegel - Sch\u00f6ner Lapislazuliziegel - Polierter sch\u00f6ner Steinziegel - Sch\u00f6ner Redstoneziegel - Sch\u00f6ner Knochenziegel - Sch\u00f6ner Schleimziegel - Sch\u00f6ner blauer Schleimziegel - Sch\u00f6ner Enderziegel - Sch\u00f6ner Obsidianziegel - Steinstra\u00dfe - Sch\u00f6ner Steinziegel + Schöner Obsidianziegel + Schöner Sandsteinziegel + Schöner Nethersteinziegel + Schöner Eisenziegel + Schöner Goldziegel + Schöner Diamantziegel + Schöner Lapislazuliziegel + Polierter schöner Steinziegel + Schöner Redstoneziegel + Schöner Knochenziegel + Schöner Schleimziegel + Schöner blauer Schleimziegel + Schöner Enderziegel + Schöner Obsidianziegel + Steinstraße + Schöner Steinziegel Eisenbeere Goldbeere @@ -112,7 +112,7 @@ Schleimkristall Versengter Ziegel Cobaltbarren - Ardiumbarren + Arditbarren ManyullynBarren Moosballen Lavakristall @@ -135,6 +135,13 @@ Duraluminiumklumpen Seide Seidiger Edelstein + Obsidianklumpen + Cobaltklumpen + Arditklumpen + Manyullynklumpen + Bronzeklumpen + Alumitklumpen + Stahlklumpen Schmelzereikern Schmelzereiausguss @@ -143,8 +150,8 @@ Versengter Cobblestone Versengter Pflasterstein Rissiger versengter Ziegel - Versengte Stra\u00dfe - Versengter sch\u00f6ner Ziegel + Versengte Straße + Versengter schöner Ziegel Versengter ziselierter Ziegel Versengter ziselierter Ziegel @@ -152,14 +159,20 @@ Versengtes Glas Versengtes Fenster - - Zugbr\u00fccke + Zugbrücke Feuerzeug + Landmine + Punji-Stab + Eichen-Barrikade + Fichten-Barrikade + Birken-Barrikade + Tropen-Barrikade Cobaltblock - Ardiumblock + Arditblock Manyullynblock Kupferblock + Bronzeblock Zinnblock Aluminiumblock Duraluminiumblock @@ -167,59 +180,63 @@ Stahlblock Fackel + Handwerksstation Klares Glas Seelenglas Klares Seelenglas - - Wei\u00df get\u00f6ntes Glas - Orange get\u00f6ntes Glas - Magenta get\u00f6ntes Glas - Hellblau get\u00f6ntes Glas - Gelb get\u00f6ntes Glas - Hellgr\u00fcn get\u00f6ntes Glas - Rosa get\u00f6ntes Glas - Grau get\u00f6ntes Glas - Hellgrau get\u00f6ntes Glas - Zyan get\u00f6ntes Glas - Violett get\u00f6ntes Glas - Blau get\u00f6ntes Glas - Braun get\u00f6ntes Glas - Gr\u00fcn get\u00f6ntes Glas - Rot get\u00f6ntes Glas - Schwarz get\u00f6ntes Glas - Wei\u00df get\u00f6nte Glasscheibe - Orange get\u00f6nte Glasscheibe - Magenta get\u00f6nte Glasscheibe - Hellblau get\u00f6nte Glasscheibe - Gelb get\u00f6nte Glasscheibe - Hellgr\u00fcn get\u00f6nte Glasscheibe - Rosa get\u00f6nte Glasscheibe - Grau get\u00f6nte Glasscheibe - Hellgrau get\u00f6nte Glasscheibe - Zyan get\u00f6nte Glasscheibe - Violett get\u00f6nte Glasscheibe - Blau get\u00f6nte Glasscheibe - Braun get\u00f6nte Glasscheibe - Gr\u00fcn get\u00f6nte Glasscheibe - Rot get\u00f6nte Glasscheibe - Schwarz get\u00f6nte Glasscheibe + Klare Glasscheibe + Seelenglasscheibe + Klare Seelenglasscheibe + + Weiß getöntes Glas + Orange getöntes Glas + Magenta getöntes Glas + Hellblau getöntes Glas + Gelb getöntes Glas + Hellgrün getöntes Glas + Rosa getöntes Glas + Grau getöntes Glas + Hellgrau getöntes Glas + Türkis getöntes Glas + Violett getöntes Glas + Blau getöntes Glas + Braun getöntes Glas + Grün getöntes Glas + Rot getöntes Glas + Schwarz getöntes Glas + + Weiß getönte Glasscheibe + Orange getönte Glasscheibe + Magenta getönte Glasscheibe + Hellblau getönte Glasscheibe + Gelb getönte Glasscheibe + Hellgrün getönte Glasscheibe + Rosa getönte Glasscheibe + Grau getönte Glasscheibe + Hellgrau getönte Glasscheibe + Türkis getönte Glasscheibe + Violett getönte Glasscheibe + Blau getönte Glasscheibe + Braun getönte Glasscheibe + Grün getönte Glasscheibe + Rot getönte Glasscheibe + Schwarz getönte Glasscheibe Versengte Ziegelstufe Versengte Steinstufe Versengte Cobblestonestufe Versengte Pflasterstufe - Versengte Stra\u00dfenstufe - Versengte sch\u00f6ne Stufe + Versengte Straßenstufe + Versengte schöne Stufe Versengte ziselierte Stufe Versengte ziselierte Stufe - Erdstufe Myzelstufe Schleimige Matschstufe - M\u00f6rtelstufe + Mörtelstufe Schleimige Matschstufe (blau) Friedhofserdenstufe Gesegnete Erdstufe @@ -230,53 +247,52 @@ Bogensehne Verzauberte Bogensehne - Federne Befiederung - Bl\u00e4tterne Befiederung + Blätterne Befiederung Schleimige Befiederung Blaue schleimige Befiederung Aller Anfang ist schwer Du und deine Materialien - Die M\u00e4chtige Schmelzerei + Die Mächtige Schmelzerei - Eimer mit fl\u00fcssigem Eisen - Eimer mit fl\u00fcssigem Gold - Eimer mit fl\u00fcssigem Kupfer - Eimer mit fl\u00fcssigem Zinn - Eimer mit fl\u00fcssigem Aluminium - Eimer mit fl\u00fcssigem Cobalt - Eimer mit fl\u00fcssigem Ardium - Eimer mit fl\u00fcssigem Bronze - Eimer mit fl\u00fcssigem Duraluminium - Eimer mit fl\u00fcssigem Manyullyn - Eimer mit fl\u00fcssigem Alumit - Eimer mit fl\u00fcssigem Obsidian - Eimer mit fl\u00fcssigem Stahl - Eimer mit fl\u00fcssigem Glas + Eimer mit flüssigem Eisen + Eimer mit flüssigem Gold + Eimer mit flüssigem Kupfer + Eimer mit flüssigem Zinn + Eimer mit flüssigem Aluminium + Eimer mit flüssigem Cobalt + Eimer mit flüssigem Ardit + Eimer mit flüssigem Bronze + Eimer mit flüssigem Duraluminium + Eimer mit flüssigem Manyullyn + Eimer mit flüssigem Alumit + Eimer mit flüssigem Obsidian + Eimer mit flüssigem Stahl + Eimer mit flüssigem Glas Eimer mit versengtem Gestein - Eimer mit fl\u00fcssigem Smaragd + Eimer mit flüssigem Smaragd Eimer mit Blut Bogensehne Verzauberte Bogensehne - Fl\u00fcssiges Eisen - Fl\u00fcssiges Gold - Fl\u00fcssiges Kupfer - Fl\u00fcssiges Zinn - Fl\u00fcssiges Aluminium - Fl\u00fcssiges Cobalt - Fl\u00fcssiges Ardium - Fl\u00fcssige Bronze - Fl\u00fcssiges Duraluminium - Fl\u00fcssiges Manyullyn - Fl\u00fcssiges Alumit - Fl\u00fcssiger Obsidian - Fl\u00fcssiger Stahl - Fl\u00fcssiges Glas - Fl\u00fcssiges Gestein - Fl\u00fcssiger Smaragd + Flüssiges Eisen + Flüssiges Gold + Flüssiges Kupfer + Flüssiges Zinn + Flüssiges Aluminium + Flüssiges Cobalt + Flüssiges Ardit + Flüssige Bronze + Flüssiges Duraluminium + Flüssiges Manyullyn + Flüssiges Alumit + Flüssiger Obsidian + Flüssiger Stahl + Flüssiges Glas + Flüssiges Gestein + Flüssiger Smaragd Blut Verzierter Apfel @@ -291,14 +307,14 @@ Gussbecken Blauer Schleim - K\u00f6nigsschleim - Schutzschleim + Königsschleim + Schutzschleim - R\u00fcstungs-GUI + Rüstungs-GUI %1$s wurde in eine Proteinmasse verwandelt %1$s ist mit der Schmelzerei eins geworden - %1$s wird ein Meilenstein f\u00fcr unsere Revolution sein! - %1$s dachte, das Schwimmen in hei\u00dfen Fl\u00fcssigkeiten w\u00e4re eine gute Idee + %1$s wird ein Meilenstein für unsere Revolution sein! + %1$s dachte, das Schwimmen in heißen Flüssigkeiten wäre eine gute Idee - \ No newline at end of file + diff --git a/assets/tinker/lang/en_US.xml b/assets/tinker/lang/en_US.xml index b1598026..a339446f 100644 --- a/assets/tinker/lang/en_US.xml +++ b/assets/tinker/lang/en_US.xml @@ -21,6 +21,7 @@ Casting Table Tool Forge + Crafting Station Drying Rack Slimy Mud Grout @@ -160,6 +161,11 @@ Drawbridge Igniter Landmine + Punji Stick + Oak Barricade + Spruce Barricade + Birch Barricade + Jungle Barricade Block of Cobalt Block of Ardite @@ -267,12 +273,12 @@ Bucket o' Blood Bowstring - Enchanted Bowstring + Enchanted Bowstring Molten Iron Molten Gold Molten Copper - Liquid Tin + Molten Tin Molten Aluminum Molten Cobalt Molten Ardite @@ -286,6 +292,12 @@ Seared Stone Liquified Emerald Blood + Molten Nickel + Molten Lead + Molten Silver + Molten Shiny + Molten Invar + Molten Electrum Jeweled Apple Gelatinous Slime @@ -331,4 +343,28 @@ Steel Slime + Molten Iron + Molten Gold + Molten Copper + Molten Tin + Molten Aluminum + Molten Cobalt + Molten Ardite + Molten Bronze + Molten Aluminum Brass + Molten Manyullyn + Molten Alumite + Molten Obsidian + Molten Steel + Molten Glass + Seared Stone + Liquified Emerald + Blood + Molten Nickel + Molten Lead + Molten Silver + Molten Platinum + Molten Invar + Molten Shiny + \ No newline at end of file diff --git a/assets/tinker/lang/ru_RU.xml b/assets/tinker/lang/ru_RU.xml new file mode 100644 index 00000000..3ceabfaa --- /dev/null +++ b/assets/tinker/lang/ru_RU.xml @@ -0,0 +1,334 @@ + + + + TConstruct инструменты + TConstruct материалы + TConstruct блоки + + Инструментальная станция + Инструментальная кузница + Создатель деталей + Трафаретный стол + Сундук со схемами + Плавильня + Сковорода + Ранец + + Инструментальная станция + Создатель деталей + Сундук со схемами + Трафаретный стол/entry> + Литейный стол + + Инструментальная кузница + Штатив для сушки + Слизистая грязь + Осадок + Слизистая грязь + Кладбищенская почва + Священная почва + + Адская окалина + Кобальтовая руда + Ардитовая руда + Медная руда + Оловянная руда + Алюминиевая руда + Каменная окалина + + Железный рудный куст + Золотой рудный куст + Медный рудный куст + Оловянный рудный куст + Алюминиевый рудный куст + Куст рудной эссенции + + Железная гравиевая руда + Золотая гравиевая руда + Медная гравиевая руда + Оловянная гравиевая руда + Алюминиевая гравиевая руда + Кобальтовая гравиевая руда + + Грубый бурый песчаник + Дорога из грубого бурого песчаника + Бурый песчаник + Кирпич из бурого песчаника + Дорога из бурго песчаника + Красивый бурый песчаник + Резной бурый песчаник + + Плита из грубого бурого песчаника + Плита из грубого дорожного бурого песчаника + Плита из бурого песчаника + Плита из кирпича бурого песчаника + Плита из дорожного бурого песчаника + Плита из красивого бурого песчаника + Плита из резного бурого песчаника + + Обсидиановый кирпич + Песчаный кирпич + Адский кирпич + Железный кирпич + Золотой кирпич + Алмазный кирпич + Лазуритовый кирпич + Кирпич из отполированного камня + Редстоун кирпич + Костяной кирпич + Слизистый кирпич + Слизистый кирпич + Кирпич из камня края + Обсидиановый кирпич + + Красивый обсидиановый кирпич + Красивый песчаный кирпич + Красивый адский кирпич + Красивый железный кирпич + Красивый золотой кирпич + Красивый алмазный кирпич + Красивый лазуритовый кирпич + Кирпич из красивого отполированного камня + Кирпич из красивого редстоуна + Красивый костяной кирпич + Красивый слизистый кирпич + Красивый слизистый кирпич + Кирпич из красивого камня края + Красивый обсидиановый кирпич + Каменная дорого + Кирпич из красивого камня + + Кусочки железа + Кусочки золота + Кусочки меди + Кусочки олова + Кусочки алюминия + Кусочки концентрированной эссенции + + Золотистая голова + Spawn + + Кучка бумаги + Кристалл слизи + Обожжённый кирпич + Кобальтовый слиток + Ардитовый слиток + Мануллиновый слиток + Шарик мха + Кристалл лавы + Некротическая кость + Медный слиток + Оловянный слиток + Алюминиевый слиток + Необработанный алюминий + Бронзовый слиток + Слиток алюминиевой латуни + Алюмитовый слиток + Стальной слиток + Кристалл слизи + Обсидиановый слиток + Железный самородок + Медный самородок + Оловянный самородок + Алюминиевый самородок + Кристалл эссенции + Самородок алюминиевой латуни + Обсидиановый самородок + Кобальтовый самородок + Ардитовый самородок + Мануллиновый самородок + Бронзовый самородок + Алюмитовый самородок + Кусочек стали + + Контроллер плавильни + Водосток плавильни + Обожжённые кирпичи + Обожжённый камень + Обожжённый булыжник + Обожжённая брусчатка + Потресканные обожжённые кирпичи + Обожжённая дорога + Красивые обожжённые кирпичи + Резные обожжённые кирпичи + Резные обожжённые кирпичи + + Обожжённый резервуар + Обожжённое стекло + Обожжённое окно + + Разводной мост + Воспламенитель + Фугас + + Кобальтовый блок + Ардитовый блок + Мануллиновый блок + Медный блок + Бронзовый блок + Оловянный блок + Алюминиевый блок + Блок алюминиевой латуни + Алюмитовый блок + Стальной блок + + Факел + + Чистое стекло + Душевное стекло + Чистое душевное стекло + + Чистая стеклянная панель + Душевная стеклянная панель + Чистая душевная стеклянная панель + + Белое стекло + Оранжевое стекло + Сиреневое стекло + Светло-синее стекло + Жёлтое стекло + Лаймовое стекло + Розовое стекло + Серое стекло + Светло-серое стекло + Бирюзовое стекло + Фиолетовое стекло + Синее стекло + Коричневое стекло + Зелёное стекло + Красное стекло + Чёрное стекло + + Белая стеклянная панель + Оранжевая стеклянная панель + Сиреневая стеклянная панель + Светло-синяя стеклянная панель + Жёлтая стеклянная панель + Лаймовая стеклянная панель + Розовая стеклянная панель + Серая стеклянная панель + Светло-серая стеклянная панель + Бирюзовая стеклянная панель + Фиолетовая стеклянная панель + Синяя стеклянная панель + Коричневая стеклянная панель + Зелёная стеклянная панель + Красная стеклянная панель + Чёрная стеклянная панель + + Плита из обожжённого кирпича + Плита из обожжённого камня + Плита из обожжённого булыжника + Плита из обожжённой брусчатки + Плита из обожжённой дороги + Красивая обожжённая плита + Резная обожжённая плита + Резная обожжённая плита + + Земляная плита + Плита из широкого мицелия + Плита из слизистой грязи + Плита из осадка + Плита из слизистой грязи + Плита из кладбищенской почвы + Плита из священной почвы + + Ранец + Пустая схема + Чистый чугун + + Тетива + Зачарованная тетива + Feather Fletching + Leaf Fletching + Slime Fletching + Slime Fletching + + Материалы и Вы + Материалы и Вы + Могучая металлургия + + Ведро расплавленного железа + Ведро расплавленного золота + Ведро расплавленной меди + Ведро расплавленного олова + Ведро расплавленного алюминия + Ведро расплавленного кобальта + Ведро расплавленного ардита + Ведро расплавленной бронзы + Ведро расплавленной алюминиевой латуни + Ведро расплавленного мануллина + Ведро расплавленного алюмита + Ведро расплавленного обсидиана + Ведро расплавленной стали + Ведро расплавленного стекла + Ведро расплавленного обожжённого камня + Ведро сжиженного изумруда + Ведро крови + + Тетива + Зачарованная тетива + + Расплавленное железо + Расплавленное золото + Расплавленная медь + Жидкое олово + Расплавленной алюминий + Расплавленный кобальт + Расплавленный ардит + Расплавленная бронза + Расплавленная алюминиевая латунь + Расплавленный мануллин + Расплавленный алюмит + Расплавленный обсидиан + Расплавленная сталь + Расплавленное стекло + Расплавленный обожжённый камень + Сжиженный изумруд + Кровь + + Драгоценное яблоко + Желатиновая слизь + Пустая жестяная коробка + Миниатюрное красное сердце + Лечащая жестяная коробка + Dirtmover Gloves + + Литейный стол + Seared Faucet + Литейный резервуар + + Синий слизень + Король слизней + Слизень охраник + + Armor Gui + + %1$s превратился в зелёный сойлент + %1$s сплавился с плавильней + %1$s станет ступенькой в нашей революции! + %1$s думал, что купание в горячих жидкостях хорошая идея + + %1$s наблюдал за тем как его ноги взорвались + %1$s был обречён на смерть от мины + %1$s взял поездку на фейерверк + + Wooden + Stone + Iron + Flint + Cactus + Bone + Obsidian + Slime + Paper + Cobalt + Ardite + Manyullyn + Copper + Bronze + Alumite + Steel + Slime + + diff --git a/assets/tinker/lang/zh_CN.xml b/assets/tinker/lang/zh_CN.xml new file mode 100644 index 00000000..268a5690 --- /dev/null +++ b/assets/tinker/lang/zh_CN.xml @@ -0,0 +1,336 @@ + + + + 匠魂|工具 + 匠魂|材料 + 匠魂|方块 + + 工具组装台 + 工具装配站 + 零件加工台 + Stencil Table + 模具箱 + 冶炼厂 + 煎锅 + 背包 + + 工具组装台 + 零件加工台 + 模具箱 + 模具桌 + 浇铸台 + + 工具装配站 + 晾干架 + 黏滑泥泞 + 水泥 + 黏滑蓝泥泞 + 黄泉土 + 神圣土 + + 下界岩碎渣 + 钴矿石 + 阿迪特矿石 + 铜矿石 + 锡矿石 + 铝矿石 + 石渣 + + 铁矿莓丛 + 金矿莓丛 + 铜矿莓丛 + 锡矿莓丛 + 铝矿莓丛 + 精华莓丛 + + 铁矿砂砾 + 金矿砂砾 + 铜矿砂砾 + 锡矿砂砾 + 铝矿砂砾 + 钴矿砂砾 + + 光滑褐岩 + 光滑褐岩铺路石 + 褐岩 + 褐岩砖 + 褐岩铺路石 + 平滑褐岩砖 + 錾制褐岩砖 + + 光滑褐岩台阶 + 光滑褐岩铺路台阶 + 褐岩台阶 + 褐岩砖台阶 + 褐岩铺路石台阶 + 平滑褐岩砖台阶 + 錾制褐岩砖台阶 + + 黑曜石砖块 + 沙石砖块 + 平滑下界岩砖块 + 铁砖块 + 金砖块 + 钻石砖块 + 青金石砖块 + 抛光石砖块 + 红石砖块 + 白骨砖块 + 史莱姆砖块 + 蓝色史莱姆砖快 + 末地石砖块 + 黑曜石锭砖 + + 平滑黑曜石砖 + 平滑沙石砖 + 平滑下界岩砖 + 平滑铁砖 + 平滑金砖 + 平滑钻石砖 + 平滑青金石砖 + 平滑抛光石砖 + 平滑红石砖 + 平滑骨砖 + 平滑史莱姆砖 + 平滑蓝史莱姆砖 + 平滑末地石砖 + 平滑黑曜石锭砖 + 铺路石 + 平滑石砖 + + 铁矿莓丛 + 金矿莓丛 + 铜矿莓丛 + 锡矿莓丛 + 铝矿莓丛 + 精华莓丛 + + 黄金头颅 + 生成 + + 一叠纸 + 粘液球水晶 + 焦黑砖 + 钴锭t + 阿迪特锭 + 玛玉灵锭 + 苔藓球 + 熔岩水晶 + 坏死之骨 + 铜锭 + 锡锭 + 铝锭 + 生铝 + 青铜锭 + 含铝黄铜锭 + 耐酸铝锭 + 钢锭 + 蓝色史莱姆水晶 + 黑曜石锭 + 铁粒 + 铜粒 + 锡粒 + 铝粒 + 精华水晶 + 含铝黄铜粒 + 绢布 + 精致珠宝 + 黑曜石粒 + 钴粒 + 阿迪特粒 + 玛玉灵粒 + 青铜粒 + 耐酸铝粒 + 钢粒 + + 冶炼厂填料仓 + 铸造盆 + 冶炼炉砖 + 焦黑石头 + 焦黑圆石 + 焦黑盖板石 + 裂纹焦黑石砖 + 焦黑铺路石 + 平滑焦黑石砖 + 裂纹焦黑石砖 + 雕琢焦黑石砖 + + 冶炼槽 + 冶炼炉玻璃 + 冶炼炉视窗 + + 造桥器 + 点火器 + 地雷 + + 钴方块 + 阿迪特方块 + 玛玉灵方块 + 铜方块 + 青铜方块 + 锡方块 + 铝方块 + 含铝黄铜方块 + 耐酸铝方块 + 钢方块 + + 石柄火把 + + 澄澈玻璃 + 灵魂玻璃 + 澄澈灵魂玻璃 + + 澄澈玻璃板 + 灵魂玻璃板 + 澄澈灵魂玻璃板 + + 白色强化玻璃 + 橙色强化玻璃 + 品红色强化玻璃 + 浅蓝色强化玻璃 + 黄色强化玻璃 + 柠檬色强化玻璃 + 粉色强化玻璃 + 灰色强化玻璃 + 浅灰色强化玻璃 + 青色强化玻璃 + 紫色强化玻璃 + 蓝色强化玻璃 + 棕色强化玻璃 + 绿色强化玻璃 + 红色强化玻璃 + 黑色强化玻璃 + + 白色强化玻璃板 + 橙色强化玻璃板 + 品红色强化玻璃板 + 浅蓝色强化玻璃板 + 黄色强化玻璃板 + 柠檬色强化玻璃板 + 粉色强化玻璃板 + 灰色强化玻璃板 + 浅灰色强化玻璃板 + 青色强化玻璃板 + 紫色强化玻璃板 + 蓝色强化玻璃板 + 棕色强化玻璃板 + 绿色强化玻璃板 + 红色强化玻璃板 + 黑色强化玻璃板 + + 焦黑石砖台阶 + 焦黑石头台阶 + 焦黑圆石台阶 + 焦黑垫脚石台阶 + 焦黑铺路石台阶 + 平滑焦黑石头台阶 + 裂纹焦黑石头台阶 + 雕琢焦黑石头台阶 + + 泥土台阶 + 菌丝台阶 + 史莱姆台阶 + 水泥台阶 + 蓝史莱姆台阶 + 黄泉土台阶 + 混泥土台阶 + + 背包 + 空白模具 + 空白铸形 + + 弓弦 + 附魔弓弦 + 羽毛箭羽 + 树叶箭羽 + 史莱姆箭羽 + 蓝史莱姆箭羽 + + 匠魂宝典Ⅰ + 匠魂宝典Ⅱ + 冶炼秘术 + + 桶装液态铁 + 桶装液态黄金 + 桶装液态铜 + 桶装液态锡 + 桶装液态铝 + 桶装液态钴 + 桶装液态阿迪特 + 桶装液态青铜 + 桶装液态含铝黄铜 + 桶装液态玛玉灵 + 桶装液态耐酸铝 + 桶装液态黑曜石 + 桶装液态钢 + 桶装液态玻璃 + 桶装熔融石头 + 桶装液态绿宝石 + 血桶 + + 弓弦 + 附魔弓弦 + + 液态铁 + 液态黄金 + 液态铜 + 液态锡 + 液态铝 + 液态钴 + 液态阿迪特 + 液态青铜 + 液态含铝黄铜 + 液态玛玉灵 + 液态耐酸铝 + 液态黑曜石 + 液态钢 + 液态玻璃 + 熔融石头 + 液态绿宝石 + 血 + + 宝石苹果 + 胶状黏液 + 心之容器(空) + 微型红心 + 心之容器 + 鼹鼠手套 + + 浇注台 + 浇注道 + 铸造盆 + + 蓝色史莱姆 + 史莱姆王 + 史莱姆护卫 + + 装备界面 + + %1$s被加工成了"绿色食品"! + %1$s被冶炼炉融化了! + %1$s将成为我们革命的垫脚石! + %1$s认为在炽热的液体中游泳是个不错的注意! + + %1$s眼看着他们的腿被炸飞了! + %1$s被地雷炸死了! + %1$s骑着烟花火箭飞上了西天! + + 木 + 石 + 铁 + 燧石 + 仙人掌 + 骨头 + 黑曜石 + 史莱姆 + 纸 + 钴 + 阿迪特 + 玛玉灵 + 铜 + 青铜 + 耐酸铝 + 钢 + 蓝色史莱姆 + + diff --git a/assets/tinker/textures/blocks/craftingstation_bottom.png b/assets/tinker/textures/blocks/craftingstation_bottom.png new file mode 100644 index 00000000..0d2abb0a Binary files /dev/null and b/assets/tinker/textures/blocks/craftingstation_bottom.png differ diff --git a/assets/tinker/textures/blocks/craftingstation_side.png b/assets/tinker/textures/blocks/craftingstation_side.png new file mode 100644 index 00000000..ca9429b8 Binary files /dev/null and b/assets/tinker/textures/blocks/craftingstation_side.png differ diff --git a/assets/tinker/textures/blocks/craftingstation_top.png b/assets/tinker/textures/blocks/craftingstation_top.png new file mode 100644 index 00000000..8d6bccfd Binary files /dev/null and b/assets/tinker/textures/blocks/craftingstation_top.png differ diff --git a/assets/tinker/textures/blocks/golemcore.png b/assets/tinker/textures/blocks/golemcore.png deleted file mode 100644 index 69138cf2..00000000 Binary files a/assets/tinker/textures/blocks/golemcore.png and /dev/null differ diff --git a/assets/tinker/textures/blocks/golemhead_face.png b/assets/tinker/textures/blocks/golemhead_face.png deleted file mode 100644 index 347bf8b6..00000000 Binary files a/assets/tinker/textures/blocks/golemhead_face.png and /dev/null differ diff --git a/assets/tinker/textures/blocks/golemhead_side.png b/assets/tinker/textures/blocks/golemhead_side.png deleted file mode 100644 index 76cc0094..00000000 Binary files a/assets/tinker/textures/blocks/golemhead_side.png and /dev/null differ diff --git a/assets/tinker/textures/blocks/golemhead_top.png b/assets/tinker/textures/blocks/golemhead_top.png deleted file mode 100644 index 91f23025..00000000 Binary files a/assets/tinker/textures/blocks/golemhead_top.png and /dev/null differ diff --git a/assets/tinker/textures/blocks/punji.png b/assets/tinker/textures/blocks/punji.png new file mode 100644 index 00000000..b25debb2 Binary files /dev/null and b/assets/tinker/textures/blocks/punji.png differ diff --git a/assets/tinker/textures/blocks/smeltery_furnace_off.png b/assets/tinker/textures/blocks/smeltery_furnace_off.png new file mode 100644 index 00000000..de9b0116 Binary files /dev/null and b/assets/tinker/textures/blocks/smeltery_furnace_off.png differ diff --git a/assets/tinker/textures/blocks/smeltery_furnace_on.png b/assets/tinker/textures/blocks/smeltery_furnace_on.png new file mode 100644 index 00000000..aa10a92f Binary files /dev/null and b/assets/tinker/textures/blocks/smeltery_furnace_on.png differ diff --git a/assets/tinker/textures/gui/crafting.png b/assets/tinker/textures/gui/crafting.png new file mode 100644 index 00000000..254daccd Binary files /dev/null and b/assets/tinker/textures/gui/crafting.png differ diff --git a/assets/tinker/textures/gui/drawbridge.png b/assets/tinker/textures/gui/drawbridge.png index bc66b666..f247f1d0 100644 Binary files a/assets/tinker/textures/gui/drawbridge.png and b/assets/tinker/textures/gui/drawbridge.png differ diff --git a/ic2/api/Direction.java b/ic2/api/Direction.java index 751375ab..ee5e536f 100644 --- a/ic2/api/Direction.java +++ b/ic2/api/Direction.java @@ -1,6 +1,7 @@ package ic2.api; import net.minecraft.tileentity.TileEntity; + import net.minecraftforge.common.ForgeDirection; /** @@ -15,7 +16,7 @@ public enum Direction { * +X */ XP(1), - + /** * -Y */ @@ -24,7 +25,7 @@ public enum Direction { * +Y */ YP(3), // 1... - + /** * -Z */ @@ -33,19 +34,19 @@ public enum Direction { * +Z */ ZP(5); - + Direction(int dir) { this.dir = dir; } - + /*public CoordinateTuple ApplyToCoordinates(CoordinateTuple coordinates) { CoordinateTuple ret = new CoordinateTuple(coordinates); - + ret.coords[dir/2] += GetSign(); - + return ret; }*/ - + /** * Get the tile entity next to a tile entity following this direction. * @@ -54,16 +55,16 @@ public enum Direction { */ public TileEntity applyToTileEntity(TileEntity tileEntity) { int coords[] = { tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord }; - + coords[dir/2] += getSign(); - + if (tileEntity.worldObj != null && tileEntity.worldObj.blockExists(coords[0], coords[1], coords[2])) { return tileEntity.worldObj.getBlockTileEntity(coords[0], coords[1], coords[2]); } else { return null; } } - + /** * Get the inverse of this direction (XN -> XP, XP -> XN, etc.) * @@ -71,14 +72,14 @@ public enum Direction { */ public Direction getInverse() { int inverseDir = dir - getSign(); - + for (Direction direction : directions) { if (direction.dir == inverseDir) return direction; } - + return this; } - + /** * Convert this direction to a Minecraft side value. * @@ -87,7 +88,7 @@ public enum Direction { public int toSideValue() { return (dir + 4) % 6; } - + /** * Determine direction sign (N for negative or P for positive). * @@ -96,12 +97,12 @@ public enum Direction { private int getSign() { return (dir % 2) * 2 - 1; } - + public ForgeDirection toForgeDirection() { return ForgeDirection.getOrientation(toSideValue()); } - + private int dir; - private static final Direction[] directions = Direction.values(); + public static final Direction[] directions = Direction.values(); } diff --git a/ic2/api/crops/CropCard.java b/ic2/api/crops/CropCard.java index 1d1d171d..c0345645 100644 --- a/ic2/api/crops/CropCard.java +++ b/ic2/api/crops/CropCard.java @@ -2,10 +2,11 @@ package ic2.api.crops; import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.entity.Entity; -import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.Icon; + import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -322,9 +323,9 @@ public abstract class CropCard */ public boolean onEntityCollision(ICropTile crop, Entity entity) { - if (entity instanceof EntityLiving) + if (entity instanceof EntityLivingBase) { - return ((EntityLiving)entity).isSprinting(); + return ((EntityLivingBase)entity).isSprinting(); } return false; } @@ -360,7 +361,7 @@ public abstract class CropCard { return Crops.instance.getIdFor(this); } - + @SideOnly(Side.CLIENT) protected Icon textures[]; } diff --git a/ic2/api/crops/Crops.java b/ic2/api/crops/Crops.java index e054b1f9..c3ee5154 100644 --- a/ic2/api/crops/Crops.java +++ b/ic2/api/crops/Crops.java @@ -3,6 +3,7 @@ package ic2.api.crops; import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.item.ItemStack; import net.minecraft.world.biome.BiomeGenBase; + import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -11,7 +12,7 @@ import cpw.mods.fml.relauncher.SideOnly; */ public abstract class Crops { public static Crops instance; - + /** * Adds a crop humidity and nutrient biome bonus. * @@ -22,30 +23,30 @@ public abstract class Crops { * @param nutrientsBonus Nutrient stat bonus */ public abstract void addBiomeBonus(BiomeGenBase biome, int humidityBonus, int nutrientsBonus); - + /** - * Gets the humidity bonus for a biome. + * Gets the humidity bonus for a biome. * * @param biome Biome to check * @return Humidity bonus or 0 if none */ public abstract int getHumidityBiomeBonus(BiomeGenBase biome); - + /** - * Gets the nutrient bonus for a biome. + * Gets the nutrient bonus for a biome. * * @param biome Biome to check * @return Nutrient bonus or 0 if none */ public abstract int getNutrientBiomeBonus(BiomeGenBase biome); - + /** * Returns the list of registered crops. - * + * * @return Registered crops by ID */ public abstract CropCard[] getCropList(); - + /** * Auto-assign an ID to a plant and register it. * Usage of this method is not recommended! Other plants could take your IDs and cause your plants to turn into other plants. @@ -54,7 +55,7 @@ public abstract class Crops { * @return The ID assigned to the plant */ public abstract short registerCrop(CropCard crop); - + /** * Attempt to register a plant to an ID. * If the ID is taken, the crop will not be registered and a console print will notify the user. @@ -64,7 +65,7 @@ public abstract class Crops { * @return Whether the crop was registered */ public abstract boolean registerCrop(CropCard crop, int i); - + /** * Registers a base seed, an item used to plant a crop. * @@ -77,14 +78,14 @@ public abstract class Crops { * @return True if successful */ public abstract boolean registerBaseSeed(ItemStack stack, int id, int size, int growth, int gain, int resistance); - + /** * Finds a base seed from the given item. * * @return Base seed or null if none found */ public abstract BaseSeed getBaseSeed(ItemStack stack); - + /** * Execute registerSprites for all registered crop cards. * @@ -92,7 +93,7 @@ public abstract class Crops { */ @SideOnly(Side.CLIENT) public abstract void startSpriteRegistration(IconRegister iconRegister); - + /** * Returns the ID for the given crop. * diff --git a/ic2/api/info/IEnergyValueProvider.java b/ic2/api/info/IEnergyValueProvider.java new file mode 100644 index 00000000..50e84e6e --- /dev/null +++ b/ic2/api/info/IEnergyValueProvider.java @@ -0,0 +1,14 @@ +package ic2.api.info; + +import net.minecraft.item.ItemStack; + +public interface IEnergyValueProvider { + /** + * Determine the energy value for a single item in the supplied stack. + * The value is used by most machines in the discharge slot. + * + * @param itemStack ItemStack containing the item to evaluate. + * @return energy in EU + */ + int getEnergyValue(ItemStack itemStack); +} diff --git a/ic2/api/info/IFuelValueProvider.java b/ic2/api/info/IFuelValueProvider.java new file mode 100644 index 00000000..7c7fe0f4 --- /dev/null +++ b/ic2/api/info/IFuelValueProvider.java @@ -0,0 +1,15 @@ +package ic2.api.info; + +import net.minecraft.item.ItemStack; + +public interface IFuelValueProvider { + /** + * Determine the fuel value for a single item in the supplied stack. + * The information currently applies to Generators and the Iron Furnace. + * + * @param itemStack ItemStack containing the item to evaluate. + * @param allowLava Determine if lava has a fuel value, currently only true for the Iron Furnace. + * @return fuel value + */ + int getFuelValue(ItemStack itemStack, boolean allowLava); +} diff --git a/ic2/api/info/Info.java b/ic2/api/info/Info.java new file mode 100644 index 00000000..48b85d7e --- /dev/null +++ b/ic2/api/info/Info.java @@ -0,0 +1,6 @@ +package ic2.api.info; + +public class Info { + public static IEnergyValueProvider itemEnergy; + public static IFuelValueProvider itemFuel; +} diff --git a/ic2/api/item/ElectricItem.java b/ic2/api/item/ElectricItem.java index 051a76b0..511220fd 100644 --- a/ic2/api/item/ElectricItem.java +++ b/ic2/api/item/ElectricItem.java @@ -1,7 +1,5 @@ package ic2.api.item; -import java.lang.reflect.Method; - import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; @@ -12,6 +10,20 @@ import net.minecraft.item.ItemStack; * ignoreTransferLimit and simulate set to true. */ public final class ElectricItem { + /** + * IElectricItemManager to use for interacting with IElectricItem ItemStacks. + * + * This manager will act as a gateway and delegate the tasks to the final implementation + * (rawManager or a custom one) as necessary. + */ + public static IElectricItemManager manager; + + /** + * Standard IElectricItemManager implementation, only call it directly from another + * IElectricItemManager. Use manager instead. + */ + public static IElectricItemManager rawManager; + /** * Charge an item with a specified amount of energy * @@ -21,15 +33,12 @@ public final class ElectricItem { * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() * @param simulate don't actually change the item, just determine the return value * @return Energy transferred into the electric item + * + * @deprecated use manager.charge() instead */ + @Deprecated public static int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) { - try { - if (ElectricItem_charge == null) ElectricItem_charge = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("charge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE); - - return (Integer) ElectricItem_charge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate); - } catch (Exception e) { - throw new RuntimeException(e); - } + return manager.charge(itemStack, amount, tier, ignoreTransferLimit, simulate); } /** @@ -41,15 +50,12 @@ public final class ElectricItem { * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() * @param simulate don't actually discharge the item, just determine the return value * @return Energy retrieved from the electric item + * + * @deprecated use manager.discharge() instead */ + @Deprecated public static int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate) { - try { - if (ElectricItem_discharge == null) ElectricItem_discharge = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("discharge", ItemStack.class, Integer.TYPE, Integer.TYPE, Boolean.TYPE, Boolean.TYPE); - - return (Integer) ElectricItem_discharge.invoke(null, itemStack, amount, tier, ignoreTransferLimit, simulate); - } catch (Exception e) { - throw new RuntimeException(e); - } + return manager.discharge(itemStack, amount, tier, ignoreTransferLimit, simulate); } /** @@ -60,15 +66,12 @@ public final class ElectricItem { * @param itemStack electric item's stack * @param amount minimum amount of energy required * @return true if there's enough energy + * + * @deprecated use manager.canUse() instead */ + @Deprecated public static boolean canUse(ItemStack itemStack, int amount) { - try { - if (ElectricItem_canUse == null) ElectricItem_canUse = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("canUse", ItemStack.class, Integer.TYPE); - - return (Boolean) ElectricItem_canUse.invoke(null, itemStack, amount); - } catch (Exception e) { - throw new RuntimeException(e); - } + return manager.canUse(itemStack, amount); } /** @@ -79,15 +82,12 @@ public final class ElectricItem { * @param amount amount of energy to discharge in EU * @param player player holding the item * @return true if the operation succeeded + * + * @deprecated use manager.use() instead */ + @Deprecated public static boolean use(ItemStack itemStack, int amount, EntityPlayer player) { - try { - if (ElectricItem_use == null) ElectricItem_use = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("use", ItemStack.class, Integer.TYPE, EntityPlayer.class); - - return (Boolean) ElectricItem_use.invoke(null, itemStack, amount, player); - } catch (Exception e) { - throw new RuntimeException(e); - } + return manager.use(itemStack, amount, player); } /** @@ -97,38 +97,12 @@ public final class ElectricItem { * * @param itemStack electric item's stack * @param player player holding the item + * + * @deprecated use manager.chargeFromArmor() instead */ + @Deprecated public static void chargeFromArmor(ItemStack itemStack, EntityPlayer player) { - try { - if (ElectricItem_chargeFromArmor == null) ElectricItem_chargeFromArmor = Class.forName(getPackage() + ".core.item.ElectricItem").getMethod("chargeFromArmor", ItemStack.class, EntityPlayer.class); - - ElectricItem_chargeFromArmor.invoke(null, itemStack, player); - } catch (Exception e) { - throw new RuntimeException(e); - } + manager.chargeFromArmor(itemStack, player); } - - /** - * Get the base IC2 package name, used internally. - * - * @return IC2 package name, if unable to be determined defaults to ic2 - */ - private static String getPackage() { - Package pkg = ElectricItem.class.getPackage(); - - if (pkg != null) { - String packageName = pkg.getName(); - - return packageName.substring(0, packageName.length() - ".api.item".length()); - } - - return "ic2"; - } - - private static Method ElectricItem_charge; - private static Method ElectricItem_discharge; - private static Method ElectricItem_canUse; - private static Method ElectricItem_use; - private static Method ElectricItem_chargeFromArmor; } diff --git a/ic2/api/item/ICustomElectricItem.java b/ic2/api/item/ICustomElectricItem.java index 8c1baea4..9f4b1a68 100644 --- a/ic2/api/item/ICustomElectricItem.java +++ b/ic2/api/item/ICustomElectricItem.java @@ -10,12 +10,15 @@ import net.minecraft.item.ItemStack; * * The default implementation (when not using ICustomElectricItem) does the following: * - store and retrieve the charge - * - handle charging, taking amount, tier, transfer limit and simulate into account + * - handle charging, taking amount, tier, transfer limit, canProvideEnergy and simulate into account * - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId()) * - update and manage the damage value for the visual charge indicator * * @note ICustomElectricItem must not call the ElectricItem methods charge, discharge or canUse + * + * @deprecated Use ISpecialElectricItem instead. */ +@Deprecated public interface ICustomElectricItem extends IElectricItem { /** * Charge an item with a specified amount of energy diff --git a/ic2/api/item/IElectricItemManager.java b/ic2/api/item/IElectricItemManager.java new file mode 100644 index 00000000..88eab750 --- /dev/null +++ b/ic2/api/item/IElectricItemManager.java @@ -0,0 +1,92 @@ +package ic2.api.item; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; + +/** + * This interface specifies a manager to handle the various tasks for electric items. + * + * The default implementation does the following: + * - store and retrieve the charge + * - handle charging, taking amount, tier, transfer limit, canProvideEnergy and simulate into account + * - replace item IDs if appropriate (getChargedItemId() and getEmptyItemId()) + * - update and manage the damage value for the visual charge indicator + * + * @note If you're implementing your own variant (ISpecialElectricItem), you can delegate to the + * default implementations through ElectricItem.rawManager. The default implementation is designed + * to minimize its dependency on its own constraints/structure and delegates most work back to the + * more atomic features in the gateway manager. + */ +public interface IElectricItemManager { + /** + * Charge an item with a specified amount of energy + * + * @param itemStack electric item's stack + * @param amount amount of energy to charge in EU + * @param tier tier of the charging device, has to be at least as high as the item to charge + * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() + * @param simulate don't actually change the item, just determine the return value + * @return Energy transferred into the electric item + */ + int charge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate); + + /** + * Discharge an item by a specified amount of energy + * + * @param itemStack electric item's stack + * @param amount amount of energy to charge in EU + * @param tier tier of the discharging device, has to be at least as high as the item to discharge + * @param ignoreTransferLimit ignore the transfer limit specified by getTransferLimit() + * @param simulate don't actually discharge the item, just determine the return value + * @return Energy retrieved from the electric item + */ + int discharge(ItemStack itemStack, int amount, int tier, boolean ignoreTransferLimit, boolean simulate); + + /** + * Determine the charge level for the specified item + * + * @param itemStack ItemStack containing the electric item + * @return charge level in EU + */ + int getCharge(ItemStack itemStack); + + /** + * Determine if the specified electric item has at least a specific amount of EU. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * BatPacks are not taken into account. + * + * @param itemStack electric item's stack + * @param amount minimum amount of energy required + * @return true if there's enough energy + */ + boolean canUse(ItemStack itemStack, int amount); + + /** + * Try to retrieve a specific amount of energy from an Item, and if applicable, a BatPack. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * + * @param itemStack electric item's stack + * @param amount amount of energy to discharge in EU + * @param entity entity holding the item + * @return true if the operation succeeded + */ + boolean use(ItemStack itemStack, int amount, EntityLivingBase entity); + + /** + * Charge an item from the BatPack a player is wearing. + * This is supposed to be used in the item code during operation, for example if you want to implement your own electric item. + * use() already contains this functionality. + * + * @param itemStack electric item's stack + * @param entity entity holding the item + */ + void chargeFromArmor(ItemStack itemStack, EntityLivingBase entity); + + /** + * Get the tool tip to display for electric items. + * + * @param itemStack ItemStack to determine the tooltip for + * @return tool tip string or null for none + */ + String getToolTip(ItemStack itemStack); +} diff --git a/ic2/api/item/ISpecialElectricItem.java b/ic2/api/item/ISpecialElectricItem.java new file mode 100644 index 00000000..a7302f53 --- /dev/null +++ b/ic2/api/item/ISpecialElectricItem.java @@ -0,0 +1,13 @@ +package ic2.api.item; + +import net.minecraft.item.ItemStack; + +public interface ISpecialElectricItem extends IElectricItem { + /** + * Supply a custom IElectricItemManager. + * + * @param itemStack ItemStack to get the manager for + * @return IElectricItemManager instance + */ + IElectricItemManager getManager(ItemStack itemStack); +} diff --git a/ic2/api/network/NetworkHelper.java b/ic2/api/network/NetworkHelper.java index 0981dafb..48ecc2ad 100644 --- a/ic2/api/network/NetworkHelper.java +++ b/ic2/api/network/NetworkHelper.java @@ -149,16 +149,11 @@ public final class NetworkHelper { * This method doesn't do anything if executed on the server. * * @param dataProvider Object implementing the INetworkDataProvider interface + * + * @deprecated no need to call this anymore, IC2 initiates it automatically */ + @Deprecated public static void requestInitialData(INetworkDataProvider dataProvider) { - try { - if (NetworkManager_requestInitialData == null) NetworkManager_requestInitialData = Class.forName(getPackage() + ".core.network.NetworkManager").getMethod("requestInitialData", INetworkDataProvider.class); - if (instance == null) instance = getInstance(); - - NetworkManager_requestInitialData.invoke(instance, dataProvider); - } catch (Exception e) { - throw new RuntimeException(e); - } } /** @@ -236,7 +231,6 @@ public final class NetworkHelper { private static Method NetworkManager_initiateTileEntityEvent; private static Method NetworkManager_initiateItemEvent; private static Method NetworkManager_announceBlockUpdate; - private static Method NetworkManager_requestInitialData; private static Method NetworkManager_initiateClientTileEntityEvent; private static Method NetworkManager_initiateClientItemEvent; } diff --git a/ic2/api/reactor/IReactor.java b/ic2/api/reactor/IReactor.java index 7a321879..7fcbd699 100644 --- a/ic2/api/reactor/IReactor.java +++ b/ic2/api/reactor/IReactor.java @@ -88,6 +88,12 @@ public interface IReactor { * * @return Energy output after adding the value, not multiplied by the base EU/t value */ + public float addOutput(float energy); + + /** + * Deprecated to avoid immediate API breaking. Don't use. + */ + @Deprecated public int addOutput(int energy); /** diff --git a/ic2/api/tile/IWrenchable.java b/ic2/api/tile/IWrenchable.java index b82c6ffb..f0144169 100644 --- a/ic2/api/tile/IWrenchable.java +++ b/ic2/api/tile/IWrenchable.java @@ -52,7 +52,7 @@ public interface IWrenchable { * Determine the item the block will drop when the wrenching is successful. * * @param entityPlayer player using the wrench, may be null - * @return Item to drop + * @return Item to drop, may be null */ ItemStack getWrenchDrop(EntityPlayer entityPlayer); } diff --git a/tconstruct/TConstruct.java b/tconstruct/TConstruct.java index 1323d772..ad0fd168 100644 --- a/tconstruct/TConstruct.java +++ b/tconstruct/TConstruct.java @@ -37,7 +37,7 @@ import cpw.mods.fml.common.registry.VillagerRegistry; * @dependencies: IC2 API, MFR API */ -@Mod(modid = "TConstruct", name = "TConstruct", version = "1.6.2_1.4.dev.25", dependencies = "required-after:Forge@[7.7.1.687,)") +@Mod(modid = "TConstruct", name = "TConstruct", version = "1.6.2_1.4.dev.26", dependencies = "required-after:Forge@[7.7.1.687,)") @NetworkMod(serverSideRequired = false, clientSideRequired = true, channels = { "TConstruct" }, packetHandler = tconstruct.util.network.TPacketHandler.class) public class TConstruct { diff --git a/tconstruct/blocks/CraftingStationBlock.java b/tconstruct/blocks/CraftingStationBlock.java new file mode 100644 index 00000000..630b413f --- /dev/null +++ b/tconstruct/blocks/CraftingStationBlock.java @@ -0,0 +1,114 @@ +package tconstruct.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import tconstruct.TConstruct; +import tconstruct.blocks.logic.CraftingStationLogic; +import tconstruct.client.block.TableRender; +import tconstruct.common.TProxyCommon; +import tconstruct.library.TConstructRegistry; +import tconstruct.library.blocks.InventoryBlock; + +public class CraftingStationBlock extends InventoryBlock +{ + public CraftingStationBlock(int id, Material material) + { + super(id, material); + this.setCreativeTab(TConstructRegistry.blockTab); + this.setHardness(2f); + this.setStepSound(Block.soundWoodFootstep); + } + + //Block.hasComparatorInputOverride and Block.getComparatorInputOverride + + /* Rendering */ + @Override + public String[] getTextureNames () + { + String[] textureNames = { "craftingstation_top", "craftingstation_side", "craftingstation_bottom"}; + + return textureNames; + } + + @Override + public Icon getIcon (int side, int meta) + { + return icons[meta * 3 + getTextureIndex(side)]; + } + + public int getTextureIndex (int side) + { + if (side == 0) + return 2; + if (side == 1) + return 0; + + return 1; + } + + @Override + public boolean renderAsNormalBlock () + { + return false; + } + + @Override + public boolean isOpaqueCube () + { + return false; + } + + @Override + public int getRenderType () + { + return TableRender.tabelModelID; + } + + @Override + public boolean shouldSideBeRendered (IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) + { + return true; + } + + @Override + public TileEntity createTileEntity (World world, int metadata) + { + switch (metadata) + { + case 0: + return new CraftingStationLogic(); + default: + return null; + } + } + + @Override + public Integer getGui (World world, int x, int y, int z, EntityPlayer entityplayer) + { + return TProxyCommon.craftingStationID; + } + + @Override + public Object getModInstance () + { + return TConstruct.instance; + } + + @Override + public void getSubBlocks (int id, CreativeTabs tab, List list) + { + for (int iter = 0; iter < 1; iter++) + { + list.add(new ItemStack(id, 1, iter)); + } + } +} diff --git a/tconstruct/blocks/LavaTankBlock.java b/tconstruct/blocks/LavaTankBlock.java index 81d9ecba..a5bf3e5d 100644 --- a/tconstruct/blocks/LavaTankBlock.java +++ b/tconstruct/blocks/LavaTankBlock.java @@ -2,18 +2,16 @@ package tconstruct.blocks; import java.util.List; -import tconstruct.blocks.logic.LavaTankLogic; -import tconstruct.client.block.TankRender; -import tconstruct.library.TConstructRegistry; -import tconstruct.library.util.IServantLogic; - import net.minecraft.block.Block; import net.minecraft.block.BlockContainer; import net.minecraft.block.material.Material; import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Icon; import net.minecraft.world.IBlockAccess; @@ -22,7 +20,10 @@ import net.minecraftforge.common.ForgeDirection; import net.minecraftforge.fluids.FluidContainerRegistry; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidTankInfo; -import net.minecraftforge.fluids.IFluidTank; +import tconstruct.blocks.logic.LavaTankLogic; +import tconstruct.client.block.TankRender; +import tconstruct.library.TConstructRegistry; +import tconstruct.library.util.IServantLogic; public class LavaTankBlock extends BlockContainer { @@ -243,4 +244,58 @@ public class LavaTankBlock extends BlockContainer ((IServantLogic) logic).notifyMasterOfChange(); } } + + public boolean removeBlockByPlayer(World world, EntityPlayer player, int x, int y, int z) + { + player.addExhaustion(0.025F); + int meta = world.getBlockMetadata(x, y, z); + ItemStack stack = new ItemStack(this.blockID, 1, meta); + LavaTankLogic logic = (LavaTankLogic) world.getBlockTileEntity(x, y, z); + FluidStack liquid = logic.tank.getFluid(); + if (liquid != null) + { + NBTTagCompound tag = new NBTTagCompound(); + NBTTagCompound liquidTag = new NBTTagCompound(); + liquid.writeToNBT(liquidTag); + tag.setCompoundTag("Fluid", liquidTag); + stack.setTagCompound(tag); + } + dropTankBlock(world, x, y, z, stack); + + return world.setBlockToAir(x, y, z); + } + + protected void dropTankBlock(World world, int x, int y, int z, ItemStack stack) + { + if (!world.isRemote && world.getGameRules().getGameRuleBooleanValue("doTileDrops")) + { + float f = 0.7F; + double d0 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; + double d1 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; + double d2 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(world, (double)x + d0, (double)y + d1, (double)z + d2, stack); + entityitem.delayBeforeCanPickup = 10; + world.spawnEntityInWorld(entityitem); + } + } + + public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) + { + + } + + @Override + public void onBlockPlacedBy (World world, int x, int y, int z, EntityLivingBase living, ItemStack stack) + { + if (stack.hasTagCompound()) + { + NBTTagCompound liquidTag = stack.getTagCompound().getCompoundTag("Fluid"); + if (liquidTag != null) + { + FluidStack liquid = FluidStack.loadFluidStackFromNBT(liquidTag); + LavaTankLogic logic = (LavaTankLogic) world.getBlockTileEntity(x, y, z); + logic.tank.setFluid(liquid); + } + } + } } diff --git a/tconstruct/blocks/RedstoneMachine.java b/tconstruct/blocks/RedstoneMachine.java index 4168a750..f4f6a950 100644 --- a/tconstruct/blocks/RedstoneMachine.java +++ b/tconstruct/blocks/RedstoneMachine.java @@ -4,6 +4,21 @@ import static net.minecraftforge.common.ForgeDirection.UP; import java.util.List; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeDirection; import tconstruct.TConstruct; import tconstruct.blocks.logic.DrawbridgeLogic; import tconstruct.blocks.logic.FirestarterLogic; @@ -13,19 +28,6 @@ import tconstruct.library.blocks.InventoryBlock; import tconstruct.library.util.IActiveLogic; import tconstruct.library.util.IFacingLogic; -import net.minecraft.block.Block; -import net.minecraft.block.material.Material; -import net.minecraft.client.renderer.texture.IconRegister; -import net.minecraft.creativetab.CreativeTabs; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.IInventory; -import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.Icon; -import net.minecraft.world.IBlockAccess; -import net.minecraft.world.World; -import net.minecraftforge.common.ForgeDirection; - public class RedstoneMachine extends InventoryBlock { public RedstoneMachine(int id) @@ -200,6 +202,120 @@ public class RedstoneMachine extends InventoryBlock public void onNeighborBlockChange (World world, int x, int y, int z, int neighborBlockID) { IActiveLogic logic = (IActiveLogic) world.getBlockTileEntity(x, y, z); - logic.setActive(world.isBlockIndirectlyGettingPowered(x, y, z)); + logic.setActive(world.isBlockIndirectlyGettingPowered(x, y, z) || activeNearbyRedstone(world, x, y, z)); + } + + boolean activeNearbyRedstone (World world, int x, int y, int z) + { + return activeRedstone(world, x + 1, y, z) || activeRedstone(world, x - 1, y, z) || activeRedstone(world, x, y, z+1) || activeRedstone(world, x, y, z-1); + } + + boolean activeRedstone (World world, int x, int y, int z) + { + Block wire = Block.blocksList[world.getBlockId(x, y, z)]; + if (wire != null && wire.blockID == Block.redstoneWire.blockID) + return world.getBlockMetadata(x, y, z) > 0; + + return false; + } + + @Override + public boolean canConnectRedstone (IBlockAccess world, int x, int y, int z, int side) + { + return true; + } + + /* Keep inventory */ + @Override + public boolean removeBlockByPlayer (World world, EntityPlayer player, int x, int y, int z) + { + player.addExhaustion(0.025F); + int meta = world.getBlockMetadata(x, y, z); + if (meta == 0) + { + ItemStack stack = new ItemStack(this.blockID, 1, meta); + DrawbridgeLogic logic = (DrawbridgeLogic) world.getBlockTileEntity(x, y, z); + NBTTagCompound tag = new NBTTagCompound(); + + boolean hasTag = false; + ItemStack contents = logic.getStackInSlot(0); + if (contents != null) + { + NBTTagCompound contentTag = new NBTTagCompound(); + contents.writeToNBT(contentTag); + tag.setCompoundTag("Contents", contentTag); + hasTag = true; + } + + ItemStack camo = logic.getStackInSlot(1); + if (camo != null) + { + NBTTagCompound camoTag = new NBTTagCompound(); + camo.writeToNBT(camoTag); + tag.setCompoundTag("Camoflauge", camoTag); + hasTag = true; + } + + if (logic.getPlacementDirection() != 4) + { + tag.setByte("Placement", logic.getPlacementDirection()); + hasTag = true; + } + if (hasTag == true) + stack.setTagCompound(tag); + + dropDrawbridgeLogic(world, x, y, z, stack); + } + + return world.setBlockToAir(x, y, z); + } + + protected void dropDrawbridgeLogic (World world, int x, int y, int z, ItemStack stack) + { + if (!world.isRemote && world.getGameRules().getGameRuleBooleanValue("doTileDrops")) + { + float f = 0.7F; + double d0 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d1 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d2 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(world, (double) x + d0, (double) y + d1, (double) z + d2, stack); + entityitem.delayBeforeCanPickup = 10; + world.spawnEntityInWorld(entityitem); + } + } + + @Override + public void harvestBlock (World world, EntityPlayer player, int x, int y, int z, int meta) + { + if (meta != 0) + super.harvestBlock(world, player, x, y, z, meta); + } + + @Override + public void onBlockPlacedBy (World world, int x, int y, int z, EntityLivingBase living, ItemStack stack) + { + super.onBlockPlacedBy(world, x, y, z, living, stack); + if (stack.hasTagCompound()) + { + DrawbridgeLogic logic = (DrawbridgeLogic) world.getBlockTileEntity(x, y, z); + NBTTagCompound contentTag = stack.getTagCompound().getCompoundTag("Contents"); + if (contentTag != null) + { + ItemStack contents = ItemStack.loadItemStackFromNBT(contentTag); + logic.setInventorySlotContents(0, contents); + } + + NBTTagCompound camoTag = stack.getTagCompound().getCompoundTag("Camoflauge"); + if (camoTag != null) + { + ItemStack camoflauge = ItemStack.loadItemStackFromNBT(camoTag); + logic.setInventorySlotContents(1, camoflauge); + } + + if (stack.getTagCompound().hasKey("Placement")) + { + logic.setPlacementDirection(stack.getTagCompound().getByte("Placement")); + } + } } } diff --git a/tconstruct/blocks/logic/CraftingStationLogic.java b/tconstruct/blocks/logic/CraftingStationLogic.java new file mode 100644 index 00000000..38f764db --- /dev/null +++ b/tconstruct/blocks/logic/CraftingStationLogic.java @@ -0,0 +1,34 @@ +package tconstruct.blocks.logic; + +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.world.World; +import tconstruct.inventory.CraftingStationContainer; +import tconstruct.library.blocks.InventoryLogic; + +public class CraftingStationLogic extends InventoryLogic +{ + public CraftingStationLogic() + { + super(11); //9 for crafting, 1 for output, 1 for plans + } + + @Override + public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z) + { + return new CraftingStationContainer(inventoryplayer, this, x, y, z); + } + + @Override + protected String getDefaultName () + { + return "crafters.craftingstation"; + } + + public boolean canDropInventorySlot (int slot) + { + if (slot == 9) + return false; + return true; + } +} diff --git a/tconstruct/blocks/logic/DrawbridgeLogic.java b/tconstruct/blocks/logic/DrawbridgeLogic.java index f1c8241e..500eac46 100644 --- a/tconstruct/blocks/logic/DrawbridgeLogic.java +++ b/tconstruct/blocks/logic/DrawbridgeLogic.java @@ -1,12 +1,8 @@ package tconstruct.blocks.logic; -import tconstruct.inventory.DrawbridgeContainer; -import tconstruct.library.TConstructRegistry; -import tconstruct.library.blocks.InventoryLogic; -import tconstruct.library.util.IActiveLogic; -import tconstruct.library.util.IFacingLogic; import net.minecraft.block.Block; import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Container; import net.minecraft.item.ItemStack; @@ -17,6 +13,12 @@ import net.minecraft.network.packet.Packet132TileEntityData; import net.minecraft.util.MathHelper; import net.minecraft.world.World; import net.minecraftforge.common.ForgeDirection; +import tconstruct.inventory.DrawbridgeContainer; +import tconstruct.library.TConstructRegistry; +import tconstruct.library.blocks.InventoryLogic; +import tconstruct.library.util.IActiveLogic; +import tconstruct.library.util.IFacingLogic; +import tconstruct.util.player.FakePlayerLogic; public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IActiveLogic { @@ -25,12 +27,21 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc int ticks; byte extension; byte direction; + byte placementDirection = 4; + FakePlayerLogic fakePlayer; public DrawbridgeLogic() { super(2); } + @Override + public void setWorldObj (World par1World) + { + this.worldObj = par1World; + fakePlayer = new FakePlayerLogic(worldObj, "Player.Drawbridge", this); + } + @Override public boolean getActive () { @@ -61,6 +72,11 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc { } + public boolean canDropInventorySlot (int slot) + { + return false; + } + @Override public void setDirection (float yaw, float pitch, EntityLivingBase player) { @@ -96,6 +112,103 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc } } + /* 0 = Up + * 1 = Right + * 2 = Down + * 3 = Left + * 4 = Center, neutral + */ + public void setPlacementDirection (byte keycode) + { + if (keycode == 4) + { + fakePlayer.rotationYaw = 0; + fakePlayer.rotationPitch = 0; + } + else if (this.direction == 0 || this.direction == 1) + { + switch (keycode) + { + case 0: + fakePlayer.rotationYaw = 0; + break; + case 1: + fakePlayer.rotationYaw = 90; + break; + case 2: + fakePlayer.rotationYaw = 180; + break; + case 3: + fakePlayer.rotationYaw = 270; + break; + } + + if (this.direction == 0) + fakePlayer.rotationPitch = -90; + else + fakePlayer.rotationPitch = 90; + } + else + { + if (keycode == 0) //Forward + { + fakePlayer.rotationYaw = mapDirection() * 90; + + if (keycode == 0) + fakePlayer.rotationPitch = 90; + else + fakePlayer.rotationPitch = -90; + } + else if (keycode == 2) //Backward + { + int face = mapDirection() + 2; + if (face > 3) + face -= 4; + fakePlayer.rotationYaw = face * 90; + + if (keycode == 0) + fakePlayer.rotationPitch = 90; + else + fakePlayer.rotationPitch = -90; + } + else + { + fakePlayer.rotationPitch = 0; + + int facing = mapDirection(); + if (keycode == 1) + facing += 1; + else + facing -= 1; + + if (facing >= 4) + facing = 0; + if (facing < 0) + facing = 3; + + fakePlayer.rotationYaw = facing * 90; + } + } + placementDirection = keycode; + } + + int mapDirection () + { + if (this.direction == 2) //North + return 0; + if (this.direction == 5) //East + return 1; + if (this.direction == 3) //South + return 2; + + return 3; //West + } + + public byte getPlacementDirection () + { + return placementDirection; + } + @Override public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z) { @@ -173,12 +286,13 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc { if (inventory[0].itemID >= 4096 || Block.blocksList[inventory[0].itemID] == null) return; - - worldObj.setBlock(xPos, yPos, zPos, inventory[0].itemID, inventory[0].getItemDamage(), 3); + Block placeBlock = Block.blocksList[inventory[0].itemID]; + placeBlockAt(inventory[0], fakePlayer, worldObj, xPos, yPos, zPos, direction, 0, 0, 0, inventory[0].getItemDamage(), placeBlock); } else { - worldObj.setBlock(xPos, yPos, zPos, blockToItem, inventory[0].getItemDamage(), 3); + Block placeBlock = Block.blocksList[blockToItem]; + placeBlockAt(inventory[0], fakePlayer, worldObj, xPos, yPos, zPos, direction, 0, 0, 0, inventory[0].getItemDamage(), placeBlock); } worldObj.playSoundEffect((double) xPos + 0.5D, (double) yPos + 0.5D, (double) zPos + 0.5D, "tile.piston.out", 0.25F, worldObj.rand.nextFloat() * 0.25F + 0.6F); inventory[0].stackSize--; @@ -233,8 +347,8 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc if (inventory[0] != null && validBlock(block) && validMetadata(block.blockID, meta)) { worldObj.playSoundEffect((double) xPos + 0.5D, (double) yPos + 0.5D, (double) zPos + 0.5D, "tile.piston.in", 0.25F, worldObj.rand.nextFloat() * 0.15F + 0.6F); - worldObj.setBlock(xPos, yPos, zPos, 0); - inventory[0].stackSize++; + if (worldObj.setBlock(xPos, yPos, zPos, 0)) + inventory[0].stackSize++; } else { @@ -252,6 +366,31 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc } } + /** + * Called to actually place the block, after the location is determined + * and all permission checks have been made. + * Copied from ItemBlock + * + * @param stack The item stack that was used to place the block. This can be changed inside the method. + * @param player The player who is placing the block. Can be null if the block is not being placed by a player. + * @param side The side the player (or machine) right-clicked on. + */ + public boolean placeBlockAt (ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ, int metadata, Block block) + { + if (!world.setBlock(x, y, z, block.blockID, metadata, 3)) + { + return false; + } + + if (world.getBlockId(x, y, z) == block.blockID) + { + block.onBlockPlacedBy(world, x, y, z, player, stack); + block.onPostBlockPlaced(world, x, y, z, metadata); + } + + return true; + } + boolean validBlock (Block block) { int type = TConstructRegistry.interchangableBlockMapping[block.blockID]; @@ -286,7 +425,7 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc } if (type == 3) { - return true; //TODO: rotational metadata + return true; //TODO: rotational metadata, probably not needed anymore } if (type == 4) { @@ -298,7 +437,7 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc } return false; } - + @Override public void readFromNBT (NBTTagCompound tags) { @@ -322,11 +461,14 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc public void readCustomNBT (NBTTagCompound tags) { direction = tags.getByte("Direction"); + placementDirection = tags.getByte("Placement"); } public void writeCustomNBT (NBTTagCompound tags) { tags.setByte("Direction", direction); + tags.setByte("Placement", placementDirection); + } /* Packets */ @@ -349,10 +491,11 @@ public class DrawbridgeLogic extends InventoryLogic implements IFacingLogic, IAc { return extension != 0; } - + @Override - public void onInventoryChanged() { - super.onInventoryChanged(); - this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); - } + public void onInventoryChanged () + { + super.onInventoryChanged(); + this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } } diff --git a/tconstruct/blocks/traps/BarricadeBlock.java b/tconstruct/blocks/traps/BarricadeBlock.java index f247c1db..84c78918 100644 --- a/tconstruct/blocks/traps/BarricadeBlock.java +++ b/tconstruct/blocks/traps/BarricadeBlock.java @@ -1,30 +1,43 @@ package tconstruct.blocks.traps; -import tconstruct.client.block.BarricadeRender; -import tconstruct.library.TConstructRegistry; import net.minecraft.block.Block; import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.AxisAlignedBB; import net.minecraft.util.Icon; +import net.minecraft.world.Explosion; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import tconstruct.client.block.BarricadeRender; +import tconstruct.library.TConstructRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; public class BarricadeBlock extends Block { - public BarricadeBlock(int blockID)//, String name, int texture) + Block modelBlock; + int modelMeta; + + public BarricadeBlock(int blockID, Block model, int meta) { super(blockID, Material.wood); + this.modelBlock = model; + this.modelMeta = meta; setHardness(4.0F); this.setCreativeTab(TConstructRegistry.blockTab); - //setUnlocalizedName("barricade" + name); - //GameRegistry.addName(this, name + " Barricade"); } public Icon getIcon (int side, int meta) { - return Block.wood.getIcon(2, meta % 4); + return modelBlock.getIcon(2, modelMeta); + } + + @Override + public void registerIcons(IconRegister par1IconRegister) + { + } public boolean renderAsNormalBlock () @@ -89,4 +102,27 @@ public class BarricadeBlock extends Block } return false; } + + @Override + public void onBlockExploded (World world, int x, int y, int z, Explosion explosion) + { + double distance = (x - explosion.explosionX) + (y - explosion.explosionY) + (z - explosion.explosionZ); + distance = Math.abs(distance); + double power = (explosion.explosionSize * 2) / distance; + int meta = world.getBlockMetadata(x, y, z); + int trueMeta = meta % 4; + trueMeta -= power; + if (trueMeta < 0) + world.setBlockToAir(x, y, z); + else + world.setBlockMetadataWithNotify(x, y, z, (int) (meta - power), 3); + onBlockDestroyedByExplosion(world, x, y, z, explosion); + } + + @Override + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) + { + return true; + } } \ No newline at end of file diff --git a/tconstruct/blocks/traps/Punji.java b/tconstruct/blocks/traps/Punji.java index ae95bd3d..91f46093 100644 --- a/tconstruct/blocks/traps/Punji.java +++ b/tconstruct/blocks/traps/Punji.java @@ -1,22 +1,119 @@ package tconstruct.blocks.traps; +import java.util.Random; + import net.minecraft.block.Block; import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraft.util.DamageSource; +import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import tconstruct.client.block.PunjiRender; +import tconstruct.common.TContent; +import tconstruct.library.TConstructRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; public class Punji extends Block { public Punji(int id) { - super(id, Material.circuits); + super(id, Material.plants); + this.setBlockBounds(0.125f, 0, 0.125f, 0.875f, 0.375f, 0.875f); + this.setStepSound(Block.soundGrassFootstep); + this.setCreativeTab(TConstructRegistry.blockTab); + this.setHardness(3.0f); } @Override public void onEntityCollidedWithBlock (World world, int x, int y, int z, Entity entity) { - entity.fallDistance *= 2.0F; + if (entity instanceof EntityLivingBase) + { + int damage = world.getBlockMetadata(x, y, z) / 2 + 1; + if (entity.fallDistance > 0) + damage += ((entity.fallDistance) * 1.5 + 2); + entity.attackEntityFrom(DamageSource.cactus, damage); + ((EntityLivingBase) entity).addPotionEffect(new PotionEffect(Potion.moveSlowdown.id, 20, 1)); + } + } + + /* Right-click adds sticks */ + @Override + public boolean onBlockActivated (World world, int x, int y, int z, EntityPlayer player, int par6, float hitX, float hitY, float hitZ) + { + /*if (world.isRemote) + return false;*/ + + int meta = world.getBlockMetadata(x, y, z); + if (meta < 4) + { + ItemStack stack = player.getCurrentEquippedItem(); + if (stack != null && stack.itemID == TContent.punji.blockID) + { + world.setBlockMetadataWithNotify(x, y, z, meta + 1, 3); + world.playSoundEffect((double) ((float) x + 0.5F), (double) ((float) y + 0.5F), (double) ((float) z + 0.5F), this.stepSound.getPlaceSound(), + (this.stepSound.getVolume() + 1.0F) / 2.0F, this.stepSound.getPitch() * 0.8F); + player.swingItem(); + if (!player.capabilities.isCreativeMode) + { + stack.stackSize--; + if (stack.stackSize <= 0) + player.destroyCurrentEquippedItem(); + } + } + } + return true; + } + + @Override + public int quantityDropped(int meta, int fortune, Random random) + { + return meta + 1; + } + + /** + * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two + * adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block. + */ + public boolean isOpaqueCube () + { + return false; + } + + /** + * If this block doesn't render as an ordinary block it will return False (examples: signs, buttons, stairs, etc) + */ + public boolean renderAsNormalBlock () + { + return false; + } + + public int getRenderType () + { + return PunjiRender.model; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons (IconRegister iconRegister) + { + this.blockIcon = iconRegister.registerIcon("tinker:punji"); + } + + @Override + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) + { + return true; } } diff --git a/tconstruct/client/TClientEvents.java b/tconstruct/client/TClientEvents.java index 6979509f..fbb03516 100644 --- a/tconstruct/client/TClientEvents.java +++ b/tconstruct/client/TClientEvents.java @@ -4,6 +4,7 @@ import java.util.Random; import net.minecraft.block.Block; import net.minecraft.client.Minecraft; +import net.minecraft.client.audio.SoundPool; import net.minecraft.client.gui.ScaledResolution; import net.minecraft.client.model.ModelBiped; import net.minecraft.client.renderer.Tessellator; @@ -18,6 +19,7 @@ import net.minecraftforge.client.GuiIngameForge; import net.minecraftforge.client.event.RenderGameOverlayEvent; import net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType; import net.minecraftforge.client.event.TextureStitchEvent; +import net.minecraftforge.client.event.sound.SoundLoadEvent; import net.minecraftforge.event.ForgeSubscribe; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidRegistry; @@ -36,9 +38,9 @@ public class TClientEvents /* Sounds */ - /*boolean initSounds; + boolean initSounds; - @ForgeSubscribe + /*@ForgeSubscribe public void onSound (SoundLoadEvent event) { if (!initSounds) diff --git a/tconstruct/client/TProxyClient.java b/tconstruct/client/TProxyClient.java index 1ba0ebce..189c1ee7 100644 --- a/tconstruct/client/TProxyClient.java +++ b/tconstruct/client/TProxyClient.java @@ -61,6 +61,7 @@ import org.w3c.dom.Document; import tconstruct.TConstruct; import tconstruct.blocks.logic.CastingBasinLogic; import tconstruct.blocks.logic.CastingTableLogic; +import tconstruct.blocks.logic.CraftingStationLogic; import tconstruct.blocks.logic.DrawbridgeLogic; import tconstruct.blocks.logic.DryingRackLogic; import tconstruct.blocks.logic.FrypanLogic; @@ -82,6 +83,7 @@ import tconstruct.client.block.MachineRender; import tconstruct.client.block.OreberryRender; import tconstruct.client.block.PaneConnectedRender; import tconstruct.client.block.PaneRender; +import tconstruct.client.block.PunjiRender; import tconstruct.client.block.SearedRender; import tconstruct.client.block.SmallFontRenderer; import tconstruct.client.block.SmelteryRender; @@ -100,6 +102,7 @@ import tconstruct.client.entity.projectile.ArrowRender; import tconstruct.client.entity.projectile.DaggerRender; import tconstruct.client.entity.projectile.LaunchedItemRender; import tconstruct.client.gui.ArmorExtendedGui; +import tconstruct.client.gui.CraftingStationGui; import tconstruct.client.gui.DrawbridgeGui; import tconstruct.client.gui.FrypanGui; import tconstruct.client.gui.GlowstoneAggregatorGui; @@ -150,7 +153,6 @@ import tconstruct.library.crafting.ToolBuilder; import tconstruct.library.tools.ToolCore; import tconstruct.util.player.ArmorExtended; import tconstruct.util.player.KnapsackInventory; -import tconstruct.util.player.TPlayerStats; import com.google.common.collect.Lists; @@ -191,9 +193,10 @@ public class TProxyClient extends TProxyCommon return new GlowstoneAggregatorGui(player.inventory, (GlowstoneAggregator) world.getBlockTileEntity(x, y, z), world, x, y, z); if (ID == drawbridgeGui) return new DrawbridgeGui(player.inventory, (DrawbridgeLogic) world.getBlockTileEntity(x, y, z), world, x, y, z); - if (ID == landmineGui){ - return new GuiLandmine(new ContainerLandmine(player, (TileEntityLandmine) world.getBlockTileEntity(x, y, z))); - } + if (ID == landmineGui) + return new GuiLandmine(new ContainerLandmine(player, (TileEntityLandmine) world.getBlockTileEntity(x, y, z))); + if (ID == craftingStationID) + return new CraftingStationGui(player.inventory, (CraftingStationLogic) world.getBlockTileEntity(x, y, z), x, y, z); if (ID == manualGuiID) { @@ -367,7 +370,7 @@ public class TProxyClient extends TProxyCommon { Minecraft mc = Minecraft.getMinecraft(); MinecraftForge.EVENT_BUS.register(new TClientEvents()); - smallFontRenderer = new SmallFontRenderer(mc.gameSettings, new ResourceLocation("/font/default.png"), mc.renderEngine, false); + smallFontRenderer = new SmallFontRenderer(mc.gameSettings, new ResourceLocation("font/default.png"), mc.renderEngine, false); RenderingRegistry.registerBlockHandler(new TableRender()); RenderingRegistry.registerBlockHandler(new TableForgeRender()); RenderingRegistry.registerBlockHandler(new FrypanRender()); @@ -383,8 +386,8 @@ public class TProxyClient extends TProxyCommon RenderingRegistry.registerBlockHandler(new PaneRender()); RenderingRegistry.registerBlockHandler(new PaneConnectedRender()); RenderingRegistry.registerBlockHandler(new RenderLandmine()); + RenderingRegistry.registerBlockHandler(new PunjiRender()); //RenderingRegistry.registerBlockHandler(new BrickRender()); - //RenderingRegistry.registerBlockHandler(new BallRepeaterRender()); //Special Renderers ClientRegistry.bindTileEntitySpecialRenderer(CastingTableLogic.class, new CastingTableSpecialRenderer()); @@ -408,7 +411,7 @@ public class TProxyClient extends TProxyCommon //RenderingRegistry.registerEntityRenderingHandler(net.minecraft.entity.player.EntityPlayer.class, new PlayerArmorRender()); // <-- Works, woo! MinecraftForgeClient.registerItemRenderer(TContent.shortbow.itemID, new CustomBowRenderer()); - VillagerRegistry.instance().registerVillagerSkin(78943, new ResourceLocation("/mods/tinker/textures/mob/villagertools.png")); + VillagerRegistry.instance().registerVillagerSkin(78943, new ResourceLocation("tinker", "textures/mob/villagertools.png")); addRenderMappings(); addToolButtons(); diff --git a/tconstruct/client/block/BarricadeRender.java b/tconstruct/client/block/BarricadeRender.java index 80100674..cc0bec7a 100644 --- a/tconstruct/client/block/BarricadeRender.java +++ b/tconstruct/client/block/BarricadeRender.java @@ -1,12 +1,9 @@ package tconstruct.client.block; -import tconstruct.client.TProxyClient; import net.minecraft.block.Block; import net.minecraft.client.renderer.RenderBlocks; -import net.minecraft.client.renderer.Tessellator; -import net.minecraft.util.Icon; -import net.minecraft.util.Vec3; import net.minecraft.world.IBlockAccess; +import tconstruct.client.TProxyClient; import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; import cpw.mods.fml.client.registry.RenderingRegistry; @@ -25,46 +22,106 @@ public class BarricadeRender implements ISimpleBlockRenderingHandler if (modelId == model) { int meta = world.getBlockMetadata(x, y, z); - Tessellator tessellator = Tessellator.instance; - - if ((meta < 4) || (meta == 10) || (meta == 11)) + int type = meta % 4; + + if (meta / 4 == 0) { - renderInnerEast(renderer, world, x, y, z, (Block) barricade, tessellator); + //if (type >= 0) + renderer.setRenderBounds(0.125, 0.0, 0.5, 0.375, 1.0, 0.75); + renderer.renderStandardBlock(barricade, x, y, z); + + if (type >= 1) + { + renderer.setRenderBounds(0.625, 0.0, 0.5, 0.875, 1.0, 0.75); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 2) + { + renderer.setRenderBounds(0.0, 0.125, 0.25, 1.0, 0.375, 0.5); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 3) + { + renderer.setRenderBounds(0.0, 0.625, 0.25, 1.0, 0.875, 0.5); + renderer.renderStandardBlock(barricade, x, y, z); + } } - - if (((meta < 4) && (meta > 0)) || (meta == 11)) + + if (meta / 4 == 1) { - renderOuterEast(renderer, world, x, y, z, (Block) barricade, tessellator); + //if (type >= 0) + renderer.setRenderBounds(0.25, 0.0, 0.125, 0.5, 1.0, 0.375); + renderer.renderStandardBlock(barricade, x, y, z); + + if (type >= 1) + { + renderer.setRenderBounds(0.25, 0.0, 0.625, 0.5, 1.0, 0.875); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 2) + { + renderer.setRenderBounds(0.5, 0.125, 0.0, 0.75, 0.375, 1.0); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 3) + { + renderer.setRenderBounds(0.5, 0.625, 0.0, 0.75, 0.875, 1.0); + renderer.renderStandardBlock(barricade, x, y, z); + } } - - if ((meta == 2) || (meta == 3) || ((meta >= 8) && (meta <= 11))) + + if (meta / 4 == 2) { - renderInnerWest(renderer, world, x, y, z, (Block) barricade, tessellator); + //if (type >= 0) + renderer.setRenderBounds(0.125, 0.0, 0.25, 0.375, 1.0, 0.5); + renderer.renderStandardBlock(barricade, x, y, z); + + if (type >= 1) + { + renderer.setRenderBounds(0.625, 0.0, 0.25, 0.875, 1.0, 0.5); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 2) + { + renderer.setRenderBounds(0.0, 0.125, 0.5, 1.0, 0.375, 0.75); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 3) + { + renderer.setRenderBounds(0.0, 0.625, 0.5, 1.0, 0.875, 0.75); + renderer.renderStandardBlock(barricade, x, y, z); + } } - - if ((meta == 3) || ((meta >= 9) && (meta <= 11))) + + if (meta / 4 == 3) { - renderOuterWest(renderer, world, x, y, z, (Block) barricade, tessellator); - } - - if (((meta >= 4) && (meta <= 7)) || (meta >= 14)) - { - renderInnerSouth(renderer, world, x, y, z, (Block) barricade, tessellator); - } - - if (((meta >= 5) && (meta <= 7)) || (meta == 15)) - { - renderOuterSouth(renderer, world, x, y, z, (Block) barricade, tessellator); - } - - if ((meta == 6) || (meta == 7) || (meta >= 12)) - { - renderInnerNorth(renderer, world, x, y, z, (Block) barricade, tessellator); - } - - if ((meta == 7) || (meta >= 13)) - { - renderOuterNorth(renderer, world, x, y, z, (Block) barricade, tessellator); + //if (type >= 0) + renderer.setRenderBounds(0.5, 0.0, 0.125, 0.75, 1.0, 0.375); + renderer.renderStandardBlock(barricade, x, y, z); + + if (type >= 1) + { + renderer.setRenderBounds(0.5, 0.0, 0.625, 0.75, 1.0, 0.875); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 2) + { + renderer.setRenderBounds(0.25, 0.125, 0.0, 0.5, 0.375, 1.0); + renderer.renderStandardBlock(barricade, x, y, z); + } + + if (type >= 3) + { + renderer.setRenderBounds(0.25, 0.625, 0.0, 0.5, 0.875, 1.0); + renderer.renderStandardBlock(barricade, x, y, z); + } } return true; @@ -77,9 +134,9 @@ public class BarricadeRender implements ISimpleBlockRenderingHandler { if (modelID == model) { - block.setBlockBounds(0.375F, 0.0F, 0.375F, 0.625F, 1.0F, 0.625F); + renderer.setRenderBounds(0.375F, 0.0F, 0.375F, 0.625F, 1.0F, 0.625F); TProxyClient.renderStandardInvBlock(renderer, block, metadata); - block.setBlockBounds(0.375F, 0.375F, 0.0F, 0.625F, 0.625F, 1.0F); + renderer.setRenderBounds(0.375F, 0.375F, 0.0F, 0.625F, 0.625F, 1.0F); TProxyClient.renderStandardInvBlock(renderer, block, metadata); } } @@ -95,1041 +152,4 @@ public class BarricadeRender implements ISimpleBlockRenderingHandler { return model; } - - private static void renderInnerWest (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(renderblocks.blockAccess, x, y, z)); - float f3 = 1.0F; - - if (Block.lightValue[barricade.blockID] > 0) - { - f3 = 1.0F; - } - - tessellator.setColorOpaque_F(f3, f3, f3); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - - if (renderblocks.hasOverrideBlockTexture()) - { - icon = renderblocks.overrideBlockTexture; - } - - double d0 = (double) icon.getMinU(); - double d1 = (double) icon.getMinV(); - double d2 = (double) icon.getMaxU(); - double d3 = (double) icon.getMaxV(); - Vec3[] vec1 = new Vec3[8]; - float minSize = 0.0625F; - float maxSize = 0.0625F; - float height = 0.625F; - vec1[0] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) (-minSize), 0.0D, (double) (-maxSize)); - vec1[1] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) minSize, 0.0D, (double) (-maxSize)); - vec1[2] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) minSize, 0.0D, (double) maxSize); - vec1[3] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) (-minSize), 0.0D, (double) maxSize); - vec1[4] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) (-minSize), (double) height, (double) (-maxSize)); - vec1[5] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) minSize, (double) height, (double) (-maxSize)); - vec1[6] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) minSize, (double) height, (double) maxSize); - vec1[7] = renderblocks.blockAccess.getWorldVec3Pool().getVecFromPool((double) (-minSize), (double) height, (double) maxSize); - - int l = renderblocks.blockAccess.getBlockMetadata(x, y, z); - int i1 = l & 7; - boolean flag = (l & 8) > 0; - - for (int j1 = 0; j1 < 8; ++j1) - { - if (flag) - { - vec1[j1].zCoord -= 0.0625D; - vec1[j1].rotateAroundX(((float) Math.PI * 2F / 9F)); - } - else - { - vec1[j1].zCoord += 0.0625D; - vec1[j1].rotateAroundX(-((float) Math.PI * 2F / 9F)); - } - - if (i1 == 0 || i1 == 7) - { - vec1[j1].rotateAroundZ((float) Math.PI); - } - - if (i1 == 6 || i1 == 0) - { - vec1[j1].rotateAroundY(((float) Math.PI / 2F)); - } - - if (i1 > 0 && i1 < 5) - { - vec1[j1].yCoord -= 0.375D; - vec1[j1].rotateAroundX(((float) Math.PI / 2F)); - - if (i1 == 4) - { - vec1[j1].rotateAroundY(0.0F); - } - - if (i1 == 3) - { - vec1[j1].rotateAroundY((float) Math.PI); - } - - if (i1 == 2) - { - vec1[j1].rotateAroundY(((float) Math.PI / 2F)); - } - - if (i1 == 1) - { - vec1[j1].rotateAroundY(-((float) Math.PI / 2F)); - } - - vec1[j1].xCoord += (double) x + 0.5D; - vec1[j1].yCoord += (double) ((float) y + 0.5F); - vec1[j1].zCoord += (double) z + 0.5D; - } - else if (i1 != 0 && i1 != 7) - { - vec1[j1].xCoord += (double) x + 0.5D; - vec1[j1].yCoord += (double) ((float) y + 0.125F); - vec1[j1].zCoord += (double) z + 0.5D; - } - else - { - vec1[j1].xCoord += (double) x + 0.5D; - vec1[j1].yCoord += (double) ((float) y + 0.875F); - vec1[j1].zCoord += (double) z + 0.5D; - } - } - - Vec3 vec3 = null; - Vec3 vec31 = null; - Vec3 vec32 = null; - Vec3 vec33 = null; - - for (int k1 = 0; k1 < 6; ++k1) - { - if (k1 == 0) - { - d0 = (double) icon.getInterpolatedU(7.0D); - d1 = (double) icon.getInterpolatedV(6.0D); - d2 = (double) icon.getInterpolatedU(9.0D); - d3 = (double) icon.getInterpolatedV(8.0D); - } - else if (k1 == 2) - { - d0 = (double) icon.getInterpolatedU(7.0D); - d1 = (double) icon.getInterpolatedV(6.0D); - d2 = (double) icon.getInterpolatedU(9.0D); - d3 = (double) icon.getMaxV(); - } - - if (k1 == 0) - { - vec3 = vec1[0]; - vec31 = vec1[1]; - vec32 = vec1[2]; - vec33 = vec1[3]; - } - else if (k1 == 1) - { - vec3 = vec1[7]; - vec31 = vec1[6]; - vec32 = vec1[5]; - vec33 = vec1[4]; - } - else if (k1 == 2) - { - vec3 = vec1[1]; - vec31 = vec1[0]; - vec32 = vec1[4]; - vec33 = vec1[5]; - } - else if (k1 == 3) - { - vec3 = vec1[2]; - vec31 = vec1[1]; - vec32 = vec1[5]; - vec33 = vec1[6]; - } - else if (k1 == 4) - { - vec3 = vec1[3]; - vec31 = vec1[2]; - vec32 = vec1[6]; - vec33 = vec1[7]; - } - else if (k1 == 5) - { - vec3 = vec1[0]; - vec31 = vec1[3]; - vec32 = vec1[7]; - vec33 = vec1[4]; - } - - tessellator.addVertexWithUV(vec3.xCoord, vec3.yCoord, vec3.zCoord, d0, d3); - tessellator.addVertexWithUV(vec31.xCoord, vec31.yCoord, vec31.zCoord, d2, d3); - tessellator.addVertexWithUV(vec32.xCoord, vec32.yCoord, vec32.zCoord, d2, d1); - tessellator.addVertexWithUV(vec33.xCoord, vec33.yCoord, vec33.zCoord, d0, d1); - } - - /*tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double)icon.getMinU(); - double tex2 = (double)icon.getMinV(); - double tex3 = (double)icon.getMaxU(); - double tex4 = (double)icon.getMaxV(); - Vec3[] vec1 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec1[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec1[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec1[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec1[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec1[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec1[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec1[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec1[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - for (int var25 = 0; var25 < 8; var25++) - { - vec1[var25].zCoord -= 0.0625D; - vec1[var25].rotateAroundX(-0.7853982F); - vec1[var25].yCoord -= 0.5D; - vec1[var25].rotateAroundX(1.570796F); - - vec1[var25].xCoord += x + 0.625D; - vec1[var25].yCoord += y; - vec1[var25].zCoord += z + 0.5D; - } - - Vec3 vec1a = null; - Vec3 vec1b = null; - Vec3 vec1c = null; - Vec3 vec1d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double)icon.getInterpolatedU(7.0D); - tex2 = (double)icon.getInterpolatedV(6.0D); - tex3 = (double)icon.getInterpolatedU(9.0D); - tex4 = (double)icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double)icon.getInterpolatedU(7.0D); - tex2 = (double)icon.getInterpolatedV(6.0D); - tex3 = (double)icon.getInterpolatedU(9.0D); - tex4 = (double)icon.getMaxV(); - } - - if (iter == 0) - { - vec1a = vec1[0]; - vec1b = vec1[1]; - vec1c = vec1[2]; - vec1d = vec1[3]; - } - else if (iter == 1) - { - vec1a = vec1[7]; - vec1b = vec1[6]; - vec1c = vec1[5]; - vec1d = vec1[4]; - } - else if (iter == 2) - { - vec1a = vec1[1]; - vec1b = vec1[0]; - vec1c = vec1[4]; - vec1d = vec1[5]; - } - else if (iter == 3) - { - vec1a = vec1[2]; - vec1b = vec1[1]; - vec1c = vec1[5]; - vec1d = vec1[6]; - } - else if (iter == 4) - { - vec1a = vec1[3]; - vec1b = vec1[2]; - vec1c = vec1[6]; - vec1d = vec1[7]; - } - else if (iter == 5) - { - vec1a = vec1[0]; - vec1b = vec1[3]; - vec1c = vec1[7]; - vec1d = vec1[4]; - } - - tessellator.addVertexWithUV(vec1a.xCoord, vec1a.yCoord, vec1a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec1b.xCoord, vec1b.yCoord, vec1b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec1c.xCoord, vec1c.yCoord, vec1c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec1d.xCoord, vec1d.yCoord, vec1d.zCoord, tex1, tex3); - }*/ - } - - private static void renderOuterWest (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec2 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - - vec2[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec2[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec2[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec2[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec2[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec2[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec2[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec2[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec2[var25].zCoord -= 0.0625D; - vec2[var25].rotateAroundX(-0.7853982F); - vec2[var25].yCoord -= 0.5D; - vec2[var25].rotateAroundX(1.570796F); - - vec2[var25].xCoord += x + 0.125D; - vec2[var25].yCoord += y; - vec2[var25].zCoord += z + 0.5D; - } - Vec3 vec2a = null; - Vec3 vec2b = null; - Vec3 vec2c = null; - Vec3 vec2d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec2a = vec2[0]; - vec2b = vec2[1]; - vec2c = vec2[2]; - vec2d = vec2[3]; - } - else if (iter == 1) - { - vec2a = vec2[7]; - vec2b = vec2[6]; - vec2c = vec2[5]; - vec2d = vec2[4]; - } - else if (iter == 2) - { - vec2a = vec2[1]; - vec2b = vec2[0]; - vec2c = vec2[4]; - vec2d = vec2[5]; - } - else if (iter == 3) - { - vec2a = vec2[2]; - vec2b = vec2[1]; - vec2c = vec2[5]; - vec2d = vec2[6]; - } - else if (iter == 4) - { - vec2a = vec2[3]; - vec2b = vec2[2]; - vec2c = vec2[6]; - vec2d = vec2[7]; - } - else if (iter == 5) - { - vec2a = vec2[0]; - vec2b = vec2[3]; - vec2c = vec2[7]; - vec2d = vec2[4]; - } - - tessellator.addVertexWithUV(vec2a.xCoord, vec2a.yCoord, vec2a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec2b.xCoord, vec2b.yCoord, vec2b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec2c.xCoord, vec2c.yCoord, vec2c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec2d.xCoord, vec2d.yCoord, vec2d.zCoord, tex1, tex3); - } - } - - private static void renderInnerEast (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec3 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec3[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec3[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec3[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec3[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec3[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec3[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec3[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec3[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec3[var25].zCoord -= 0.0625D; - vec3[var25].rotateAroundX(-0.7853982F); - vec3[var25].yCoord -= 0.0625D; - vec3[var25].rotateAroundX(6.283186F); - - vec3[var25].xCoord += x + 0.375D; - vec3[var25].yCoord += y; - vec3[var25].zCoord += z; - } - - Vec3 vec3a = null; - Vec3 vec3b = null; - Vec3 vec3c = null; - Vec3 Vec3 = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec3a = vec3[0]; - vec3b = vec3[1]; - vec3c = vec3[2]; - Vec3 = vec3[3]; - } - else if (iter == 1) - { - vec3a = vec3[7]; - vec3b = vec3[6]; - vec3c = vec3[5]; - Vec3 = vec3[4]; - } - else if (iter == 2) - { - vec3a = vec3[1]; - vec3b = vec3[0]; - vec3c = vec3[4]; - Vec3 = vec3[5]; - } - else if (iter == 3) - { - vec3a = vec3[2]; - vec3b = vec3[1]; - vec3c = vec3[5]; - Vec3 = vec3[6]; - } - else if (iter == 4) - { - vec3a = vec3[2]; - vec3b = vec3[1]; - vec3c = vec3[5]; - Vec3 = vec3[6]; - } - else if (iter == 5) - { - vec3a = vec3[0]; - vec3b = vec3[3]; - vec3c = vec3[7]; - Vec3 = vec3[4]; - } - - tessellator.addVertexWithUV(vec3a.xCoord, vec3a.yCoord, vec3a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec3b.xCoord, vec3b.yCoord, vec3b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec3c.xCoord, vec3c.yCoord, vec3c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(Vec3.xCoord, Vec3.yCoord, Vec3.zCoord, tex1, tex3); - } - } - - private static void renderOuterEast (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec4 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - - vec4[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec4[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec4[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec4[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec4[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec4[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec4[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec4[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec4[var25].zCoord -= 0.0625D; - vec4[var25].rotateAroundX(-0.7853982F); - vec4[var25].yCoord -= 0.0625D; - vec4[var25].rotateAroundX(6.283186F); - - vec4[var25].xCoord += x + 0.875D; - vec4[var25].yCoord += y; - vec4[var25].zCoord += z; - } - - Vec3 vec4a = null; - Vec3 vec4b = null; - Vec3 vec4c = null; - Vec3 vec4d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec4a = vec4[0]; - vec4b = vec4[1]; - vec4c = vec4[2]; - vec4d = vec4[3]; - } - else if (iter == 1) - { - vec4a = vec4[7]; - vec4b = vec4[6]; - vec4c = vec4[5]; - vec4d = vec4[4]; - } - else if (iter == 2) - { - vec4a = vec4[1]; - vec4b = vec4[0]; - vec4c = vec4[4]; - vec4d = vec4[5]; - } - else if (iter == 3) - { - vec4a = vec4[2]; - vec4b = vec4[1]; - vec4c = vec4[5]; - vec4d = vec4[6]; - } - else if (iter == 4) - { - vec4a = vec4[2]; - vec4b = vec4[1]; - vec4c = vec4[5]; - vec4d = vec4[6]; - } - else if (iter == 5) - { - vec4a = vec4[0]; - vec4b = vec4[3]; - vec4c = vec4[7]; - vec4d = vec4[4]; - } - - tessellator.addVertexWithUV(vec4a.xCoord, vec4a.yCoord, vec4a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec4b.xCoord, vec4b.yCoord, vec4b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec4c.xCoord, vec4c.yCoord, vec4c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec4d.xCoord, vec4d.yCoord, vec4d.zCoord, tex1, tex3); - } - } - - private static void renderInnerNorth (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec1 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec1[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec1[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec1[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec1[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec1[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec1[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec1[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec1[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec1[var25].zCoord -= 0.4375D; - vec1[var25].rotateAroundX(-0.7853982F); - vec1[var25].yCoord -= 0.5D; - vec1[var25].rotateAroundY(1.570796F); - - vec1[var25].xCoord += x + 0.375D; - vec1[var25].yCoord += y + 0.1875D; - vec1[var25].zCoord += z + 0.625D; - } - - Vec3 vec1a = null; - Vec3 vec1b = null; - Vec3 vec1c = null; - Vec3 vec1d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec1a = vec1[0]; - vec1b = vec1[1]; - vec1c = vec1[2]; - vec1d = vec1[3]; - } - else if (iter == 1) - { - vec1a = vec1[7]; - vec1b = vec1[6]; - vec1c = vec1[5]; - vec1d = vec1[4]; - } - else if (iter == 2) - { - vec1a = vec1[1]; - vec1b = vec1[0]; - vec1c = vec1[4]; - vec1d = vec1[5]; - } - else if (iter == 3) - { - vec1a = vec1[2]; - vec1b = vec1[1]; - vec1c = vec1[5]; - vec1d = vec1[6]; - } - else if (iter == 4) - { - vec1a = vec1[3]; - vec1b = vec1[2]; - vec1c = vec1[6]; - vec1d = vec1[7]; - } - else if (iter == 5) - { - vec1a = vec1[0]; - vec1b = vec1[3]; - vec1c = vec1[7]; - vec1d = vec1[4]; - } - - tessellator.addVertexWithUV(vec1a.xCoord, vec1a.yCoord, vec1a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec1b.xCoord, vec1b.yCoord, vec1b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec1c.xCoord, vec1c.yCoord, vec1c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec1d.xCoord, vec1d.yCoord, vec1d.zCoord, tex1, tex3); - } - } - - private static void renderOuterNorth (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec2 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec2[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec2[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec2[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec2[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec2[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec2[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec2[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec2[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec2[var25].zCoord -= 0.4375D; - vec2[var25].rotateAroundX(-0.7853982F); - vec2[var25].yCoord -= 0.5D; - vec2[var25].rotateAroundY(1.570796F); - - vec2[var25].xCoord += x + 0.375D; - vec2[var25].yCoord += y + 0.1875D; - vec2[var25].zCoord += z + 0.125D; - } - - Vec3 vec2a = null; - Vec3 vec2b = null; - Vec3 vec2c = null; - Vec3 vec2d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec2a = vec2[0]; - vec2b = vec2[1]; - vec2c = vec2[2]; - vec2d = vec2[3]; - } - else if (iter == 1) - { - vec2a = vec2[7]; - vec2b = vec2[6]; - vec2c = vec2[5]; - vec2d = vec2[4]; - } - else if (iter == 2) - { - vec2a = vec2[1]; - vec2b = vec2[0]; - vec2c = vec2[4]; - vec2d = vec2[5]; - } - else if (iter == 3) - { - vec2a = vec2[2]; - vec2b = vec2[1]; - vec2c = vec2[5]; - vec2d = vec2[6]; - } - else if (iter == 4) - { - vec2a = vec2[3]; - vec2b = vec2[2]; - vec2c = vec2[6]; - vec2d = vec2[7]; - } - else if (iter == 5) - { - vec2a = vec2[0]; - vec2b = vec2[3]; - vec2c = vec2[7]; - vec2d = vec2[4]; - } - - tessellator.addVertexWithUV(vec2a.xCoord, vec2a.yCoord, vec2a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec2b.xCoord, vec2b.yCoord, vec2b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec2c.xCoord, vec2c.yCoord, vec2c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec2d.xCoord, vec2d.yCoord, vec2d.zCoord, tex1, tex3); - } - } - - private static void renderInnerSouth (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec3 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec3[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec3[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec3[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec3[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec3[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec3[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec3[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec3[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec3[var25].zCoord -= 0.4375D; - vec3[var25].rotateAroundX(-0.7853982F); - vec3[var25].yCoord -= 0.5D; - vec3[var25].rotateAroundY(4.712389F); - - vec3[var25].xCoord += x + 0.625D; - vec3[var25].yCoord += y + 0.1875D; - vec3[var25].zCoord += z + 0.375D; - } - Vec3 vec3a = null; - Vec3 vec3b = null; - Vec3 vec3c = null; - Vec3 Vec3 = null; - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec3a = vec3[0]; - vec3b = vec3[1]; - vec3c = vec3[2]; - Vec3 = vec3[3]; - } - else if (iter == 1) - { - vec3a = vec3[7]; - vec3b = vec3[6]; - vec3c = vec3[5]; - Vec3 = vec3[4]; - } - else if (iter == 2) - { - vec3a = vec3[1]; - vec3b = vec3[0]; - vec3c = vec3[4]; - Vec3 = vec3[5]; - } - else if (iter == 3) - { - vec3a = vec3[2]; - vec3b = vec3[1]; - vec3c = vec3[5]; - Vec3 = vec3[6]; - } - else if (iter == 4) - { - vec3a = vec3[2]; - vec3b = vec3[1]; - vec3c = vec3[5]; - Vec3 = vec3[6]; - } - else if (iter == 5) - { - vec3a = vec3[0]; - vec3b = vec3[3]; - vec3c = vec3[7]; - Vec3 = vec3[4]; - } - - tessellator.addVertexWithUV(vec3a.xCoord, vec3a.yCoord, vec3a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec3b.xCoord, vec3b.yCoord, vec3b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec3c.xCoord, vec3c.yCoord, vec3c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(Vec3.xCoord, Vec3.yCoord, Vec3.zCoord, tex1, tex3); - } - } - - private static void renderOuterSouth (RenderBlocks renderblocks, IBlockAccess iblockaccess, int x, int y, int z, Block barricade, Tessellator tessellator) - { - tessellator.setBrightness(barricade.getMixedBrightnessForBlock(iblockaccess, x, y, z)); - float color = 1.0F; - - tessellator.setColorOpaque_F(color, color, color); - Icon icon = renderblocks.getBlockIconFromSide(barricade, 0); - double tex1 = (double) icon.getMinU(); - double tex2 = (double) icon.getMinV(); - double tex3 = (double) icon.getMaxU(); - double tex4 = (double) icon.getMaxV(); - Vec3[] vec4 = new Vec3[8]; - float minSize = 0.125F; - float maxSize = 0.125F; - float height = 1.416F; - vec4[0] = Vec3.createVectorHelper(-minSize, 0.0D, -maxSize); - vec4[1] = Vec3.createVectorHelper(minSize, 0.0D, -maxSize); - vec4[2] = Vec3.createVectorHelper(minSize, 0.0D, maxSize); - vec4[3] = Vec3.createVectorHelper(-minSize, 0.0D, maxSize); - vec4[4] = Vec3.createVectorHelper(-minSize, height, -maxSize); - vec4[5] = Vec3.createVectorHelper(minSize, height, -maxSize); - vec4[6] = Vec3.createVectorHelper(minSize, height, maxSize); - vec4[7] = Vec3.createVectorHelper(-minSize, height, maxSize); - - for (int var25 = 0; var25 < 8; var25++) - { - vec4[var25].zCoord -= 0.4375D; - vec4[var25].rotateAroundX(-0.7853982F); - vec4[var25].yCoord -= 0.5D; - vec4[var25].rotateAroundY(4.712389F); - - vec4[var25].xCoord += x + 0.625D; - vec4[var25].yCoord += y + 0.1875D; - vec4[var25].zCoord += z + 0.875D; - } - - Vec3 vec4a = null; - Vec3 vec4b = null; - Vec3 vec4c = null; - Vec3 vec4d = null; - - for (int iter = 0; iter < 6; iter++) - { - if (iter == 0) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getInterpolatedV(8.0D); - } - else if (iter == 2) - { - tex1 = (double) icon.getInterpolatedU(7.0D); - tex2 = (double) icon.getInterpolatedV(6.0D); - tex3 = (double) icon.getInterpolatedU(9.0D); - tex4 = (double) icon.getMaxV(); - } - - if (iter == 0) - { - vec4a = vec4[0]; - vec4b = vec4[1]; - vec4c = vec4[2]; - vec4d = vec4[3]; - } - else if (iter == 1) - { - vec4a = vec4[7]; - vec4b = vec4[6]; - vec4c = vec4[5]; - vec4d = vec4[4]; - } - else if (iter == 2) - { - vec4a = vec4[1]; - vec4b = vec4[0]; - vec4c = vec4[4]; - vec4d = vec4[5]; - } - else if (iter == 3) - { - vec4a = vec4[2]; - vec4b = vec4[1]; - vec4c = vec4[5]; - vec4d = vec4[6]; - } - else if (iter == 4) - { - vec4a = vec4[2]; - vec4b = vec4[1]; - vec4c = vec4[5]; - vec4d = vec4[6]; - } - else if (iter == 5) - { - vec4a = vec4[0]; - vec4b = vec4[3]; - vec4c = vec4[7]; - vec4d = vec4[4]; - } - - tessellator.addVertexWithUV(vec4a.xCoord, vec4a.yCoord, vec4a.zCoord, tex1, tex4); - tessellator.addVertexWithUV(vec4b.xCoord, vec4b.yCoord, vec4b.zCoord, tex2, tex4); - tessellator.addVertexWithUV(vec4c.xCoord, vec4c.yCoord, vec4c.zCoord, tex2, tex3); - tessellator.addVertexWithUV(vec4d.xCoord, vec4d.yCoord, vec4d.zCoord, tex1, tex3); - } - } } diff --git a/tconstruct/client/block/PunjiRender.java b/tconstruct/client/block/PunjiRender.java new file mode 100644 index 00000000..29348c28 --- /dev/null +++ b/tconstruct/client/block/PunjiRender.java @@ -0,0 +1,119 @@ +package tconstruct.client.block; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.world.IBlockAccess; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; + +public class PunjiRender implements ISimpleBlockRenderingHandler +{ + public static int model = RenderingRegistry.getNextAvailableRenderId(); + + @Override + public void renderInventoryBlock (Block block, int metadata, int modelID, RenderBlocks renderer) + { + if (modelID == model) + { + renderer.setRenderBounds(0.4375, 0.0, 0.4375, 0.5625, 1.0f, 0.5625); + renderStandardInvBlock(renderer, block, metadata); + } + } + + @Override + public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelID, RenderBlocks renderer) + { + if (modelID == model) + { + int metadata = world.getBlockMetadata(x, y, z); + renderer.setRenderBounds(0.4375, 0.0, 0.4375, 0.5625, 0.375f, 0.5625); + renderer.renderStandardBlock(block, x, y, z); + if (metadata >= 1) + { + renderer.setRenderBounds(0.125, 0.0, 0.125, 0.25, 0.375f, 0.25); + renderer.renderStandardBlock(block, x, y, z); + } + if (metadata >= 2) + { + renderer.setRenderBounds(0.75, 0.0, 0.75, 0.875, 0.375f, 0.875); + renderer.renderStandardBlock(block, x, y, z); + } + if (metadata >= 3) + { + renderer.setRenderBounds(0.125, 0.0, 0.75, 0.25, 0.375f, 0.875); + renderer.renderStandardBlock(block, x, y, z); + } + if (metadata >= 4) + { + renderer.setRenderBounds(0.75, 0.0, 0.125, 0.875, 0.375f, 0.25); + renderer.renderStandardBlock(block, x, y, z); + } + /*if (metadata == 5) + { + renderer.setRenderBounds(0.0F, 0.0, 0.0F, 1.0F, 0.875F, 1.0F); + renderer.renderStandardBlock(block, x, y, z); + } + else + { + renderer.setRenderBounds(0.0F, 0.75F, 0.0F, 1.0F, 1.0F, 1.0F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.0F, 0.0F, 0.0F, 0.25F, 0.75F, 0.25F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.75F, 0.0F, 0.0F, 1.0F, 0.75F, 0.25F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.0F, 0.0F, 0.75F, 0.25F, 0.75F, 1.0F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.75F, 0.0F, 0.75F, 1.0F, 0.75F, 1.0F); + renderer.renderStandardBlock(block, x, y, z); + }*/ + } + return true; + } + + @Override + public boolean shouldRender3DInInventory () + { + return true; + } + + @Override + public int getRenderId () + { + return model; + } + + public static void renderStandardInvBlock (RenderBlocks renderblocks, Block block, int meta) + { + Tessellator tessellator = Tessellator.instance; + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, -1F, 0.0F); + renderblocks.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(0, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderblocks.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(1, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1F); + renderblocks.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(2, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderblocks.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(3, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1F, 0.0F, 0.0F); + renderblocks.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, block.getIcon(4, meta)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderblocks.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, block.getIcon(5, meta)); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } +} diff --git a/tconstruct/client/gui/CraftingStationGui.java b/tconstruct/client/gui/CraftingStationGui.java new file mode 100644 index 00000000..5452a735 --- /dev/null +++ b/tconstruct/client/gui/CraftingStationGui.java @@ -0,0 +1,43 @@ +package tconstruct.client.gui; + +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +import tconstruct.blocks.logic.CraftingStationLogic; +import tconstruct.inventory.CraftingStationContainer; + +public class CraftingStationGui extends GuiContainer +{ + public CraftingStationGui(InventoryPlayer inventoryplayer, CraftingStationLogic logic, int x, int y, int z) + { + super(new CraftingStationContainer(inventoryplayer, logic, x, y, z)); + } + + /*public void onGuiClosed () + { + System.out.println("Gui Closed"); + super.onGuiClosed(); + }*/ + + @Override + protected void drawGuiContainerForegroundLayer (int par1, int par2) + { + fontRenderer.drawString("Crafting", 28, 6, 0x404040); + fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040); + } + + private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/crafting.png"); + + @Override + protected void drawGuiContainerBackgroundLayer (float f, int i, int j) + { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.func_110434_K().func_110577_a(background); + int l = (width - xSize) / 2; + int i1 = (height - ySize) / 2; + drawTexturedModalRect(l, i1, 0, 0, xSize, ySize); + } +} diff --git a/tconstruct/client/gui/DrawbridgeButton.java b/tconstruct/client/gui/DrawbridgeButton.java new file mode 100644 index 00000000..126be8e7 --- /dev/null +++ b/tconstruct/client/gui/DrawbridgeButton.java @@ -0,0 +1,47 @@ +package tconstruct.client.gui; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class DrawbridgeButton extends GuiButton +{ + /** + * True for pointing right (next page), false for pointing left (previous page). + */ + int uPos; + int vPos; + public DrawbridgeButton(int id, int xPos, int yPos, int u, int v, int xSize, int ySize) + { + super(id, xPos, yPos, xSize, ySize, ""); + uPos = u; + vPos = v; + } + private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/drawbridge.png"); + + /** + * Draws this button to the screen. + */ + public void drawButton (Minecraft mc, int par2, int par3) + { + if (this.drawButton) + { + boolean hovering = par2 >= this.xPosition && par3 >= this.yPosition && par2 < this.xPosition + this.width && par3 < this.yPosition + this.height; + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + mc.func_110434_K().func_110577_a(background); + int offset = 0; + if (!this.enabled) + offset = 46; + else if (hovering) + offset = 92; + + this.drawTexturedModalRect(this.xPosition, this.yPosition, uPos, vPos + offset, width, height); + } + } +} diff --git a/tconstruct/client/gui/DrawbridgeGui.java b/tconstruct/client/gui/DrawbridgeGui.java index dee49a6b..66a955ef 100644 --- a/tconstruct/client/gui/DrawbridgeGui.java +++ b/tconstruct/client/gui/DrawbridgeGui.java @@ -1,7 +1,12 @@ package tconstruct.client.gui; +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; + +import net.minecraft.client.gui.GuiButton; import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.network.packet.Packet250CustomPayload; import net.minecraft.util.ResourceLocation; import net.minecraft.util.StatCollector; import net.minecraft.world.World; @@ -9,6 +14,7 @@ import net.minecraft.world.World; import org.lwjgl.opengl.GL11; import tconstruct.blocks.logic.DrawbridgeLogic; +import cpw.mods.fml.common.network.PacketDispatcher; public class DrawbridgeGui extends GuiContainer { @@ -37,4 +43,72 @@ public class DrawbridgeGui extends GuiContainer int cornerY = (height - ySize) / 2; drawTexturedModalRect(cornerX, cornerY, 0, 0, xSize, ySize); } + + public void initGui () + { + super.initGui(); + int cornerX = (this.width - this.xSize) / 2; + int cornerY = (this.height - this.ySize) / 2; + + this.buttonList.clear(); + GuiButton button = new DrawbridgeButton(0, cornerX + 131, cornerY + 18, 176, 0, 21, 22); + if (logic.getPlacementDirection() == 0) + button.enabled = false; + this.buttonList.add(button); + button = new DrawbridgeButton(1, cornerX + 146, cornerY + 34, 199, 23, 22, 21); + if (logic.getPlacementDirection() == 1) + button.enabled = false; + this.buttonList.add(button); + button = new DrawbridgeButton(2, cornerX + 132, cornerY + 48, 199, 0, 21, 22); + if (logic.getPlacementDirection() == 2) + button.enabled = false; + this.buttonList.add(button); + button = new DrawbridgeButton(3, cornerX + 117, cornerY + 34, 178, 23, 22, 21); + if (logic.getPlacementDirection() == 3) + button.enabled = false; + this.buttonList.add(button); + button = new DrawbridgeButton(4, cornerX + 135, cornerY + 40, 217, 0, 10, 10); + if (logic.getPlacementDirection() == 4) + button.enabled = false; + this.buttonList.add(button); + } + + protected void actionPerformed (GuiButton button) + { + for (Object o : buttonList) + { + GuiButton b = (GuiButton) o; + b.enabled = true; + } + button.enabled = false; + + logic.setPlacementDirection((byte) button.id); + updateServer((byte) button.id); + } + + void updateServer (byte direction) + { + ByteArrayOutputStream bos = new ByteArrayOutputStream(8); + DataOutputStream outputStream = new DataOutputStream(bos); + try + { + outputStream.writeByte(5); + outputStream.writeInt(logic.worldObj.provider.dimensionId); + outputStream.writeInt(logic.xCoord); + outputStream.writeInt(logic.yCoord); + outputStream.writeInt(logic.zCoord); + outputStream.writeByte(direction); + } + catch (Exception ex) + { + ex.printStackTrace(); + } + + Packet250CustomPayload packet = new Packet250CustomPayload(); + packet.channel = "TConstruct"; + packet.data = bos.toByteArray(); + packet.length = bos.size(); + + PacketDispatcher.sendPacketToServer(packet); + } } diff --git a/tconstruct/client/gui/SmelteryGui.java b/tconstruct/client/gui/SmelteryGui.java index 2be01dcf..c9471bcd 100644 --- a/tconstruct/client/gui/SmelteryGui.java +++ b/tconstruct/client/gui/SmelteryGui.java @@ -141,7 +141,7 @@ public class SmelteryGui extends NewContainerGui int sizeY = logic.getScaledFuelGague(52); if (mouseX >= leftX && mouseX <= leftX + sizeX && mouseY >= topY && mouseY < topY + sizeY) { - drawFluidStackTooltip(new FluidStack(Block.lavaStill.blockID, logic.fuelAmount), mouseX - cornerX + 36, mouseY - cornerY); + drawFluidStackTooltip(new FluidStack(-37, logic.fuelAmount), mouseX - cornerX + 36, mouseY - cornerY); } } } @@ -261,7 +261,7 @@ public class SmelteryGui extends NewContainerGui public List getLiquidTooltip (FluidStack liquid, boolean par2) { ArrayList list = new ArrayList(); - if (liquid.getFluid().getBlockID() == Block.lavaStill.blockID) + if (liquid.fluidID == -37) { list.add("\u00A7fFuel"); int mB = liquid.amount; @@ -270,9 +270,9 @@ public class SmelteryGui extends NewContainerGui } else { - String name = FluidRegistry.getFluidName(liquid); + String name = StatCollector.translateToLocal(FluidRegistry.getFluidName(liquid)); list.add("\u00A7f" + name); - if (name.equals("Liquified Emerald")) + if (name.equals("liquified emerald")) { float emeralds = liquid.amount / 320f; list.add("Emeralds: " + emeralds); diff --git a/tconstruct/common/TContent.java b/tconstruct/common/TContent.java index 6bec5dd0..a1ffb556 100644 --- a/tconstruct/common/TContent.java +++ b/tconstruct/common/TContent.java @@ -35,27 +35,160 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.oredict.OreDictionary; import net.minecraftforge.oredict.ShapedOreRecipe; import net.minecraftforge.oredict.ShapelessOreRecipe; - import tconstruct.TConstruct; -import tconstruct.blocks.*; -import tconstruct.blocks.logic.*; -import tconstruct.entity.*; -import tconstruct.entity.projectile.*; -import tconstruct.items.*; -import tconstruct.items.armor.*; -import tconstruct.items.blocks.*; -import tconstruct.items.tools.*; -import tconstruct.landmine.block.*; -import tconstruct.landmine.item.*; -import tconstruct.landmine.tileentity.*; -import tconstruct.library.*; -import tconstruct.library.client.*; -import tconstruct.library.crafting.*; -import tconstruct.library.tools.*; -import tconstruct.library.util.*; -import tconstruct.modifiers.*; -import tconstruct.util.*; - +import tconstruct.blocks.Aggregator; +import tconstruct.blocks.CraftingStationBlock; +import tconstruct.blocks.DryingRack; +import tconstruct.blocks.EquipBlock; +import tconstruct.blocks.GlassBlockConnected; +import tconstruct.blocks.GlassBlockConnectedMeta; +import tconstruct.blocks.GlassPane; +import tconstruct.blocks.GlassPaneStained; +import tconstruct.blocks.GravelOre; +import tconstruct.blocks.LavaTankBlock; +import tconstruct.blocks.LightCrystalBase; +import tconstruct.blocks.LiquidMetalFinite; +import tconstruct.blocks.MetalOre; +import tconstruct.blocks.MultiBrick; +import tconstruct.blocks.MultiBrickFancy; +import tconstruct.blocks.OreberryBush; +import tconstruct.blocks.OreberryBushEssence; +import tconstruct.blocks.RedstoneMachine; +import tconstruct.blocks.SearedBlock; +import tconstruct.blocks.SearedSlab; +import tconstruct.blocks.SmelteryBlock; +import tconstruct.blocks.SoilBlock; +import tconstruct.blocks.SpeedBlock; +import tconstruct.blocks.SpeedSlab; +import tconstruct.blocks.StoneTorch; +import tconstruct.blocks.TMetalBlock; +import tconstruct.blocks.ToolForgeBlock; +import tconstruct.blocks.ToolStationBlock; +import tconstruct.blocks.logic.CastingBasinLogic; +import tconstruct.blocks.logic.CastingTableLogic; +import tconstruct.blocks.logic.CraftingStationLogic; +import tconstruct.blocks.logic.DrawbridgeLogic; +import tconstruct.blocks.logic.DryingRackLogic; +import tconstruct.blocks.logic.FaucetLogic; +import tconstruct.blocks.logic.FirestarterLogic; +import tconstruct.blocks.logic.FrypanLogic; +import tconstruct.blocks.logic.GlowstoneAggregator; +import tconstruct.blocks.logic.LavaTankLogic; +import tconstruct.blocks.logic.MultiServantLogic; +import tconstruct.blocks.logic.PartCrafterLogic; +import tconstruct.blocks.logic.PatternChestLogic; +import tconstruct.blocks.logic.SmelteryDrainLogic; +import tconstruct.blocks.logic.SmelteryLogic; +import tconstruct.blocks.logic.StencilTableLogic; +import tconstruct.blocks.logic.ToolForgeLogic; +import tconstruct.blocks.logic.ToolStationLogic; +import tconstruct.blocks.traps.BarricadeBlock; +import tconstruct.blocks.traps.Punji; +import tconstruct.entity.Automaton; +import tconstruct.entity.BlueSlime; +import tconstruct.entity.Crystal; +import tconstruct.entity.FancyEntityItem; +import tconstruct.entity.MiniGardy; +import tconstruct.entity.SlimeClone; +import tconstruct.entity.projectile.ArrowEntity; +import tconstruct.entity.projectile.DaggerEntity; +import tconstruct.entity.projectile.LaunchedPotion; +import tconstruct.items.Bowstring; +import tconstruct.items.CraftingItem; +import tconstruct.items.DiamondApple; +import tconstruct.items.FilledBucket; +import tconstruct.items.Fletching; +import tconstruct.items.GoldenHead; +import tconstruct.items.Manual; +import tconstruct.items.MaterialItem; +import tconstruct.items.MetalPattern; +import tconstruct.items.OreBerries; +import tconstruct.items.Pattern; +import tconstruct.items.StrangeFood; +import tconstruct.items.TitleIcon; +import tconstruct.items.ToolPart; +import tconstruct.items.ToolPartHidden; +import tconstruct.items.ToolShard; +import tconstruct.items.armor.Glove; +import tconstruct.items.armor.HeartCanister; +import tconstruct.items.armor.Knapsack; +import tconstruct.items.armor.TArmorBase; +import tconstruct.items.blocks.BarricadeItem; +import tconstruct.items.blocks.CraftedSoilItemBlock; +import tconstruct.items.blocks.GlassBlockItem; +import tconstruct.items.blocks.GlassPaneItem; +import tconstruct.items.blocks.GravelOreItem; +import tconstruct.items.blocks.LavaTankItemBlock; +import tconstruct.items.blocks.LightCrystalItem; +import tconstruct.items.blocks.MetalItemBlock; +import tconstruct.items.blocks.MetalOreItemBlock; +import tconstruct.items.blocks.MultiBrickFancyItem; +import tconstruct.items.blocks.MultiBrickItem; +import tconstruct.items.blocks.OreberryBushItem; +import tconstruct.items.blocks.OreberryBushSecondItem; +import tconstruct.items.blocks.RedstoneMachineItem; +import tconstruct.items.blocks.SearedSlabItem; +import tconstruct.items.blocks.SearedTableItemBlock; +import tconstruct.items.blocks.SmelteryItemBlock; +import tconstruct.items.blocks.SpeedBlockItem; +import tconstruct.items.blocks.SpeedSlabItem; +import tconstruct.items.blocks.StainedGlassClearItem; +import tconstruct.items.blocks.StainedGlassClearPaneItem; +import tconstruct.items.blocks.ToolForgeItemBlock; +import tconstruct.items.blocks.ToolStationItemBlock; +import tconstruct.items.tools.Arrow; +import tconstruct.items.tools.BattleSign; +import tconstruct.items.tools.Battleaxe; +import tconstruct.items.tools.Broadsword; +import tconstruct.items.tools.Chisel; +import tconstruct.items.tools.Cleaver; +import tconstruct.items.tools.Cutlass; +import tconstruct.items.tools.Dagger; +import tconstruct.items.tools.Excavator; +import tconstruct.items.tools.FryingPan; +import tconstruct.items.tools.Hammer; +import tconstruct.items.tools.Hatchet; +import tconstruct.items.tools.Longsword; +import tconstruct.items.tools.LumberAxe; +import tconstruct.items.tools.Mattock; +import tconstruct.items.tools.Pickaxe; +import tconstruct.items.tools.PotionLauncher; +import tconstruct.items.tools.Rapier; +import tconstruct.items.tools.Scythe; +import tconstruct.items.tools.Shortbow; +import tconstruct.items.tools.Shovel; +import tconstruct.landmine.block.BlockLandmine; +import tconstruct.landmine.item.ItemBlockLandmine; +import tconstruct.landmine.tileentity.TileEntityLandmine; +import tconstruct.library.TConstructRegistry; +import tconstruct.library.client.TConstructClientRegistry; +import tconstruct.library.crafting.Detailing; +import tconstruct.library.crafting.DryingRackRecipes; +import tconstruct.library.crafting.LiquidCasting; +import tconstruct.library.crafting.PatternBuilder; +import tconstruct.library.crafting.Smeltery; +import tconstruct.library.crafting.ToolBuilder; +import tconstruct.library.tools.ToolCore; +import tconstruct.library.util.IPattern; +import tconstruct.modifiers.ModAntiSpider; +import tconstruct.modifiers.ModAttack; +import tconstruct.modifiers.ModAutoSmelt; +import tconstruct.modifiers.ModBlaze; +import tconstruct.modifiers.ModButtertouch; +import tconstruct.modifiers.ModDurability; +import tconstruct.modifiers.ModElectric; +import tconstruct.modifiers.ModExtraModifier; +import tconstruct.modifiers.ModInteger; +import tconstruct.modifiers.ModLapis; +import tconstruct.modifiers.ModPiston; +import tconstruct.modifiers.ModRedstone; +import tconstruct.modifiers.ModReinforced; +import tconstruct.modifiers.ModRepair; +import tconstruct.modifiers.ModSmite; +import tconstruct.modifiers.TActiveOmniMod; +import tconstruct.util.PHConstruct; +import tconstruct.util.RecipeRemover; +import tconstruct.util.TDispenserBehaviorSpawnEgg; import cpw.mods.fml.common.IFuelHandler; import cpw.mods.fml.common.event.FMLInterModComms; import cpw.mods.fml.common.registry.EntityRegistry; @@ -142,6 +275,8 @@ public class TContent implements IFuelHandler public static Block toolStationWood; public static Block toolStationStone; public static Block toolForge; + public static Block craftingStationWood; + public static Block heldItemBlock; public static Block craftedSoil; @@ -163,7 +298,11 @@ public class TContent implements IFuelHandler //Traps public static Block landmine; - public static Block barricade; + public static Block punji; + public static Block barricadeOak; + public static Block barricadeSpruce; + public static Block barricadeBirch; + public static Block barricadeJungle; //InfiBlocks public static Block speedBlock; @@ -308,7 +447,7 @@ public class TContent implements IFuelHandler BiomeGenBase[] wasteland = BiomeDictionary.getBiomesForType(BiomeDictionary.Type.WASTELAND); BiomeGenBase[] nether = BiomeDictionary.getBiomesForType(BiomeDictionary.Type.NETHER); - + if (PHConstruct.blueSlime) { EntityRegistry.addSpawn(BlueSlime.class, PHConstruct.blueSlimeWeight, 4, 4, EnumCreatureType.monster, plains); @@ -340,7 +479,7 @@ public class TContent implements IFuelHandler void registerBlocks () { //Tool Station - toolStationWood = new ToolStationBlock(PHConstruct.woodCrafter, Material.wood).setUnlocalizedName("ToolStation"); + toolStationWood = new ToolStationBlock(PHConstruct.woodStation, Material.wood).setUnlocalizedName("ToolStation"); GameRegistry.registerBlock(toolStationWood, ToolStationItemBlock.class, "ToolStationBlock"); GameRegistry.registerTileEntity(ToolStationLogic.class, "ToolStation"); GameRegistry.registerTileEntity(PartCrafterLogic.class, "PartCrafter"); @@ -351,6 +490,10 @@ public class TContent implements IFuelHandler GameRegistry.registerBlock(toolForge, ToolForgeItemBlock.class, "ToolForgeBlock"); GameRegistry.registerTileEntity(ToolForgeLogic.class, "ToolForge"); + craftingStationWood = new CraftingStationBlock(PHConstruct.woodCrafter, Material.wood).setUnlocalizedName("CraftingStation"); + GameRegistry.registerBlock(craftingStationWood, "CraftingStation"); + GameRegistry.registerTileEntity(CraftingStationLogic.class, "CraftingStation"); + heldItemBlock = new EquipBlock(PHConstruct.heldItemBlock, Material.wood).setUnlocalizedName("Frypan"); GameRegistry.registerBlock(heldItemBlock, "HeldItemBlock"); GameRegistry.registerTileEntity(FrypanLogic.class, "FrypanLogic"); @@ -394,19 +537,35 @@ public class TContent implements IFuelHandler GameRegistry.registerBlock(redstoneMachine, RedstoneMachineItem.class, "Redstone.Machine"); GameRegistry.registerTileEntity(DrawbridgeLogic.class, "Drawbridge"); GameRegistry.registerTileEntity(FirestarterLogic.class, "Firestarter"); - - //Landmine - landmine = new BlockLandmine(PHConstruct.landmine).setHardness(0.5F).setResistance(0F).setStepSound(Block.soundMetalFootstep).setCreativeTab(CreativeTabs.tabRedstone).setUnlocalizedName("landmine"); + + //Traps + landmine = new BlockLandmine(PHConstruct.landmine).setHardness(0.5F).setResistance(0F).setStepSound(Block.soundMetalFootstep).setCreativeTab(CreativeTabs.tabRedstone) + .setUnlocalizedName("landmine"); GameRegistry.registerBlock(landmine, ItemBlockLandmine.class, "Redstone.Landmine"); GameRegistry.registerTileEntity(TileEntityLandmine.class, "Landmine"); + punji = new Punji(PHConstruct.punji).setUnlocalizedName("trap.punji"); + GameRegistry.registerBlock(punji, "trap.punji"); + + barricadeOak = new BarricadeBlock(PHConstruct.barricadeOak, Block.wood, 0).setUnlocalizedName("trap.barricade.oak"); + GameRegistry.registerBlock(barricadeOak, BarricadeItem.class, "trap.barricade.oak"); + + barricadeSpruce = new BarricadeBlock(PHConstruct.barricadeSpruce, Block.wood, 1).setUnlocalizedName("trap.barricade.spruce"); + GameRegistry.registerBlock(barricadeSpruce, BarricadeItem.class, "trap.barricade.spruce"); + + barricadeBirch = new BarricadeBlock(PHConstruct.barricadeBirch, Block.wood, 2).setUnlocalizedName("trap.barricade.birch"); + GameRegistry.registerBlock(barricadeBirch, BarricadeItem.class, "trap.barricade.birch"); + + barricadeJungle = new BarricadeBlock(PHConstruct.barricadeJungle, Block.wood, 3).setUnlocalizedName("trap.barricade.jungle"); + GameRegistry.registerBlock(barricadeJungle, BarricadeItem.class, "trap.barricade.jungle"); + dryingRack = new DryingRack(PHConstruct.dryingRack).setUnlocalizedName("Armor.DryingRack"); GameRegistry.registerBlock(dryingRack, "Armor.DryingRack"); GameRegistry.registerTileEntity(DryingRackLogic.class, "Armor.DryingRack"); //Liquids liquidMetal = new MaterialLiquid(MapColor.tntColor); - + moltenIronFluid = new Fluid("Molten Iron"); moltenIron = new LiquidMetalFinite(PHConstruct.moltenIron, moltenIronFluid, "liquid_iron").setUnlocalizedName("metal.molten.iron"); GameRegistry.registerBlock(moltenIron, "metal.molten.iron"); @@ -542,7 +701,7 @@ public class TContent implements IFuelHandler FluidRegistry.registerFluid(moltenStoneFluid); FluidContainerRegistry.registerFluidContainer(new FluidContainerData(new FluidStack(moltenStoneFluid, 1), new ItemStack(buckets, 1, 14), new ItemStack(Item.bucketEmpty))); - moltenEmeraldFluid = new Fluid("Molten Emerald"); + moltenEmeraldFluid = new Fluid("Liquified Emerald"); moltenEmerald = new LiquidMetalFinite(PHConstruct.moltenEmerald, moltenEmeraldFluid, "liquid_villager").setUnlocalizedName("molten.emerald"); GameRegistry.registerBlock(moltenEmerald, "molten.emerald"); moltenEmeraldFluid.setBlockID(moltenEmerald).setDensity(3000).setViscosity(6000); @@ -661,8 +820,8 @@ public class TContent implements IFuelHandler glassPane = new GlassPane(PHConstruct.glassPane); GameRegistry.registerBlock(glassPane, GlassPaneItem.class, "GlassPane"); - stainedGlassClear = new GlassBlockConnectedMeta(PHConstruct.stainedGlassClear, "stained", true, "white", "orange", "magenta", "light_blue", "yellow", "lime", "pink", "gray", "light_gray", "cyan", "purple", - "blue", "brown", "green", "red", "black").setUnlocalizedName("GlassBlock.StainedClear");//new GlassBlockStained(PHConstruct.stainedGlassClear, "stainedglass_").setUnlocalizedName("GlassBlock.StainedClear"); + stainedGlassClear = new GlassBlockConnectedMeta(PHConstruct.stainedGlassClear, "stained", true, "white", "orange", "magenta", "light_blue", "yellow", "lime", "pink", "gray", "light_gray", + "cyan", "purple", "blue", "brown", "green", "red", "black").setUnlocalizedName("GlassBlock.StainedClear");//new GlassBlockStained(PHConstruct.stainedGlassClear, "stainedglass_").setUnlocalizedName("GlassBlock.StainedClear"); stainedGlassClear.stepSound = Block.soundGlassFootstep; GameRegistry.registerBlock(stainedGlassClear, StainedGlassClearItem.class, "GlassBlock.StainedClear"); @@ -1148,10 +1307,8 @@ public class TContent implements IFuelHandler ItemStack[] ingotShapes = { new ItemStack(Item.ingotIron), new ItemStack(Item.ingotGold), new ItemStack(Item.brick), new ItemStack(Item.netherrackBrick), new ItemStack(materials, 1, 2) }; for (int i = 0; i < ingotShapes.length; i++) { - TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(moltenAlubrassFluid, TConstruct.ingotLiquidValue), ingotShapes[i], - false, 50); - TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(moltenGoldFluid, TConstruct.ingotLiquidValue * 2), - ingotShapes[i], false, 50); + TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(moltenAlubrassFluid, TConstruct.ingotLiquidValue), ingotShapes[i], false, 50); + TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(moltenGoldFluid, TConstruct.ingotLiquidValue * 2), ingotShapes[i], false, 50); } ItemStack fullguardCast = new ItemStack(metalPattern, 1, 22); @@ -1557,6 +1714,19 @@ public class TContent implements IFuelHandler GameRegistry.addRecipe(new ItemStack(searedSlab, 6, 5), "bbb", 'b', new ItemStack(smeltery, 1, 9)); GameRegistry.addRecipe(new ItemStack(searedSlab, 6, 6), "bbb", 'b', new ItemStack(smeltery, 1, 10)); GameRegistry.addRecipe(new ItemStack(searedSlab, 6, 7), "bbb", 'b', new ItemStack(smeltery, 1, 11)); + + //Traps + GameRegistry.addRecipe(new ItemStack(punji, 5, 0), "b b", " b ", "b b", 'b', new ItemStack(Item.reed)); + + GameRegistry.addRecipe(new ItemStack(barricadeOak, 1, 0), "b", "b", 'b', new ItemStack(Block.wood, 1, 0)); + GameRegistry.addRecipe(new ItemStack(barricadeSpruce, 1, 0), "b", "b", 'b', new ItemStack(Block.wood, 1, 1)); + GameRegistry.addRecipe(new ItemStack(barricadeBirch, 1, 0), "b", "b", 'b', new ItemStack(Block.wood, 1, 2)); + GameRegistry.addRecipe(new ItemStack(barricadeJungle, 1, 0), "b", "b", 'b', new ItemStack(Block.wood, 1, 3)); + + GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(barricadeOak, 1, 0), "b", "b", 'b', "logWood")); + + GameRegistry.addRecipe(new ItemStack(craftingStationWood, 1, 0), "b", 'b', new ItemStack(Block.workbench)); + GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(craftingStationWood, 1, 0), "b", 'b', "crafterWood")); } void setupToolTabs () @@ -1895,7 +2065,7 @@ public class TContent implements IFuelHandler { System.out.println("[TConstruct] Thaumcraft not detected."); } - + ItemStack ingotcast = new ItemStack(metalPattern, 1, 0); LiquidCasting tableCasting = TConstructRegistry.instance.getTableCasting(); LiquidCasting basinCasting = TConstructRegistry.instance.getBasinCasting(); diff --git a/tconstruct/common/TProxyCommon.java b/tconstruct/common/TProxyCommon.java index d7a6873e..4242027d 100644 --- a/tconstruct/common/TProxyCommon.java +++ b/tconstruct/common/TProxyCommon.java @@ -32,6 +32,7 @@ public class TProxyCommon implements IGuiHandler public static int glowstoneAggregatorGui = 8; public static int drawbridgeGui = 9; public static int landmineGui = 10; + public static int craftingStationID = 11; public static int inventoryGui = 100; public static int armorGuiID = 101; diff --git a/tconstruct/inventory/CraftingStationContainer.java b/tconstruct/inventory/CraftingStationContainer.java new file mode 100644 index 00000000..550988f1 --- /dev/null +++ b/tconstruct/inventory/CraftingStationContainer.java @@ -0,0 +1,155 @@ +package tconstruct.inventory; + + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.world.World; +import tconstruct.blocks.logic.CraftingStationLogic; + +public class CraftingStationContainer extends Container +{ + /** The crafting matrix inventory (3x3). */ + public InventoryCrafting craftMatrix;// = new InventoryCrafting(this, 3, 3); + public IInventory craftResult;// = new InventoryCraftResult(); + private World worldObj; + private int posX; + private int posY; + private int posZ; + + public CraftingStationContainer(InventoryPlayer inventorplayer, CraftingStationLogic logic, int x, int y, int z) + { + this.worldObj = logic.worldObj; + this.posX = x; + this.posY = y; + this.posZ = z; + craftMatrix = new InventoryCraftingStation(this, 3, 3, logic); + craftResult = new InventoryCraftingStationResult(logic); + + this.addSlotToContainer(new SlotCrafting(inventorplayer.player, this.craftMatrix, this.craftResult, 0, 124, 35)); + + int row; + int column; + + for (row = 0; row < 3; ++row) + { + for (column = 0; column < 3; ++column) + { + this.addSlotToContainer(new Slot(this.craftMatrix, column + row * 3, 30 + column * 18, 17 + row * 18)); + } + } + + //Player Inventory + for (row = 0; row < 3; ++row) + { + for (column = 0; column < 9; ++column) + { + this.addSlotToContainer(new Slot(inventorplayer, column + row * 9 + 9, 8 + column * 18, 84 + row * 18)); + } + } + + for (column = 0; column < 9; ++column) + { + this.addSlotToContainer(new Slot(inventorplayer, column, 8 + column * 18, 142)); + } + + this.onCraftMatrixChanged(this.craftMatrix); + } + + public void onCraftMatrixChanged(IInventory par1IInventory) + { + this.craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.worldObj)); + } + + public void onContainerClosed(EntityPlayer par1EntityPlayer) + { + super.onContainerClosed(par1EntityPlayer); + + if (!this.worldObj.isRemote) + { + for (int i = 0; i < 9; ++i) + { + ItemStack itemstack = this.craftMatrix.getStackInSlotOnClosing(i); + + if (itemstack != null) + { + par1EntityPlayer.dropPlayerItem(itemstack); + } + } + } + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) + { + return par1EntityPlayer.getDistanceSq((double)this.posX + 0.5D, (double)this.posY + 0.5D, (double)this.posZ + 0.5D) <= 64.0D; + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2) + { + ItemStack itemstack = null; + Slot slot = (Slot)this.inventorySlots.get(par2); + + if (slot != null && slot.getHasStack()) + { + ItemStack itemstack1 = slot.getStack(); + itemstack = itemstack1.copy(); + + if (par2 == 0) + { + if (!this.mergeItemStack(itemstack1, 10, 46, true)) + { + return null; + } + + slot.onSlotChange(itemstack1, itemstack); + } + else if (par2 >= 10 && par2 < 37) + { + if (!this.mergeItemStack(itemstack1, 37, 46, false)) + { + return null; + } + } + else if (par2 >= 37 && par2 < 46) + { + if (!this.mergeItemStack(itemstack1, 10, 37, false)) + { + return null; + } + } + else if (!this.mergeItemStack(itemstack1, 10, 46, false)) + { + return null; + } + + if (itemstack1.stackSize == 0) + { + slot.putStack((ItemStack)null); + } + else + { + slot.onSlotChanged(); + } + + if (itemstack1.stackSize == itemstack.stackSize) + { + return null; + } + + slot.onPickupFromSlot(par1EntityPlayer, itemstack1); + } + + return itemstack; + } + + public boolean func_94530_a(ItemStack par1ItemStack, Slot par2Slot) + { + return par2Slot.inventory != this.craftResult && super.func_94530_a(par1ItemStack, par2Slot); + } +} diff --git a/tconstruct/inventory/InventoryCraftingStation.java b/tconstruct/inventory/InventoryCraftingStation.java new file mode 100644 index 00000000..04df8a47 --- /dev/null +++ b/tconstruct/inventory/InventoryCraftingStation.java @@ -0,0 +1,150 @@ +package tconstruct.inventory; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import tconstruct.library.blocks.InventoryLogic; + +public class InventoryCraftingStation extends InventoryCrafting +{ + /** the width of the crafting inventory */ + private int inventoryWidth; + + /** + * Class containing the callbacks for the events on_GUIClosed and on_CraftMaxtrixChanged. + */ + private Container eventHandler; + private InventoryLogic logic; + + public InventoryCraftingStation(Container par1Container, int size, int height, InventoryLogic logic) + { + super(par1Container, size, height); + this.eventHandler = par1Container; + this.inventoryWidth = size; + this.logic = logic; + } + + /** + * Returns the number of slots in the inventory. + */ + public int getSizeInventory() + { + return 9; + } + + public ItemStack getStackInSlot(int slot) + { + return slot >= this.getSizeInventory()+1 ? null : logic.getStackInSlot(slot+1); + } + + public ItemStack getStackInRowAndColumn(int row, int column) + { + if (row >= 0 && row < this.inventoryWidth) + { + int k = row + column * this.inventoryWidth; + return this.getStackInSlot(k); + } + else + { + return null; + } + } + + public String getInvName() + { + return "container.crafting"; + } + + public boolean isInvNameLocalized() + { + return false; + } + + public ItemStack getStackInSlotOnClosing(int par1) + { + return null; + } + + /** + * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a + * new stack. + */ + @Override + public ItemStack decrStackSize(int slotID, int par2) + { + ItemStack stack = logic.getStackInSlot(slotID+1); + if (stack != null) + { + ItemStack itemstack; + + if (stack.stackSize <= par2) + { + itemstack = stack.copy(); + stack = null; + logic.setInventorySlotContents(slotID+1, null); + this.eventHandler.onCraftMatrixChanged(this); + return itemstack; + } + else + { + itemstack = stack.splitStack(par2); + + if (stack.stackSize == 0) + { + stack = null; + } + + this.eventHandler.onCraftMatrixChanged(this); + return itemstack; + } + } + else + { + return null; + } + } + + /** + * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections). + */ + public void setInventorySlotContents(int slot, ItemStack itemstack) + { + logic.setInventorySlotContents(slot+1, itemstack); + this.eventHandler.onCraftMatrixChanged(this); + } + + /** + * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't + * this more of a set than a get?* + */ + public int getInventoryStackLimit() + { + return 64; + } + + /** + * Called when an the contents of an Inventory change, usually + */ + public void onInventoryChanged() {} + + /** + * Do not make give this method the name canInteractWith because it clashes with Container + */ + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) + { + return true; + } + + public void openChest() {} + + public void closeChest() {} + + /** + * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot. + */ + public boolean isStackValidForSlot(int par1, ItemStack par2ItemStack) + { + return true; + } +} diff --git a/tconstruct/inventory/InventoryCraftingStationResult.java b/tconstruct/inventory/InventoryCraftingStationResult.java new file mode 100644 index 00000000..633307dc --- /dev/null +++ b/tconstruct/inventory/InventoryCraftingStationResult.java @@ -0,0 +1,119 @@ +package tconstruct.inventory; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.InventoryCraftResult; +import net.minecraft.item.ItemStack; +import tconstruct.blocks.logic.CraftingStationLogic; + +public class InventoryCraftingStationResult extends InventoryCraftResult +{ + CraftingStationLogic logic; + + public InventoryCraftingStationResult(CraftingStationLogic logic) + { + this.logic = logic; + } + /** + * Returns the number of slots in the inventory. + */ + public int getSizeInventory() + { + return 1; + } + + /** + * Returns the stack in slot i + */ + public ItemStack getStackInSlot(int par1) + { + return logic.getStackInSlot(0);//this.stackResult[0]; + } + + /** + * Returns the name of the inventory. + */ + public String getInvName() + { + return "Result"; + } + + /** + * If this returns false, the inventory name will be used as an unlocalized name, and translated into the player's + * language. Otherwise it will be used directly. + */ + public boolean isInvNameLocalized() + { + return false; + } + + /** + * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and returns them in a + * new stack. + */ + public ItemStack decrStackSize(int par1, int par2) + { + ItemStack stack = logic.getStackInSlot(0); + if (stack != null) + { + ItemStack itemstack = stack; + logic.setInventorySlotContents(0, null); + return itemstack; + } + else + { + return null; + } + } + + /** + * When some containers are closed they call this on each slot, then drop whatever it returns as an EntityItem - + * like when you close a workbench GUI. + */ + public ItemStack getStackInSlotOnClosing(int par1) + { + return null; + } + + /** + * Sets the given item stack to the specified slot in the inventory (can be crafting or armor sections). + */ + @Override + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) + { + logic.setInventorySlotContents(0, par2ItemStack); + } + + /** + * Returns the maximum stack size for a inventory slot. Seems to always be 64, possibly will be extended. *Isn't + * this more of a set than a get?* + */ + public int getInventoryStackLimit() + { + return 64; + } + + /** + * Called when an the contents of an Inventory change, usually + */ + public void onInventoryChanged() {} + + /** + * Do not make give this method the name canInteractWith because it clashes with Container + */ + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) + { + return true; + } + + public void openChest() {} + + public void closeChest() {} + + /** + * Returns true if automation is allowed to insert the given stack (ignoring stack size) into the given slot. + */ + public boolean isStackValidForSlot(int par1, ItemStack par2ItemStack) + { + return true; + } +} diff --git a/tconstruct/items/blocks/BarricadeItem.java b/tconstruct/items/blocks/BarricadeItem.java new file mode 100644 index 00000000..e7961b42 --- /dev/null +++ b/tconstruct/items/blocks/BarricadeItem.java @@ -0,0 +1,106 @@ +package tconstruct.items.blocks; + +import java.util.List; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; + +public class BarricadeItem extends ItemBlock +{ + private int bID; + + public BarricadeItem(int id) + { + super(id); + this.bID = id + 256; + } + + @Override + @SideOnly(Side.CLIENT) + public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4) + { + list.add("Stacks up to 4 times"); + } + + public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) + { + int i1 = world.getBlockId(x, y, z); + + if (i1 == Block.snow.blockID && (world.getBlockMetadata(x, y, z) & 7) < 1) + { + side = 1; + } + else if (i1 != Block.vine.blockID && i1 != Block.tallGrass.blockID && i1 != Block.deadBush.blockID + && (Block.blocksList[i1] == null || !Block.blocksList[i1].isBlockReplaceable(world, x, y, z))) + { + if (side == 0) + { + --y; + } + + if (side == 1) + { + ++y; + } + + if (side == 2) + { + --z; + } + + if (side == 3) + { + ++z; + } + + if (side == 4) + { + --x; + } + + if (side == 5) + { + ++x; + } + } + + if (stack.stackSize == 0) + { + return false; + } + else if (!player.canPlayerEdit(x, y, z, side, stack)) + { + return false; + } + else if (y == 255 && Block.blocksList[this.bID].blockMaterial.isSolid()) + { + return false; + } + else if (world.canPlaceEntityOnSide(this.bID, x, y, z, false, side, player, stack)) + { + Block block = Block.blocksList[this.bID]; + //int meta = this.getMetadata(stack.getItemDamage()); + int rotation = MathHelper.floor_double((double) (player.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3; + int meta = rotation * 4; + int metadata = Block.blocksList[this.bID].onBlockPlaced(world, x, y, z, side, hitX, hitY, hitZ, meta); + + if (placeBlockAt(stack, player, world, x, y, z, side, hitX, hitY, hitZ, metadata)) + { + world.playSoundEffect((double)((float)x + 0.5F), (double)((float)y + 0.5F), (double)((float)z + 0.5F), block.stepSound.getPlaceSound(), (block.stepSound.getVolume() + 1.0F) / 2.0F, block.stepSound.getPitch() * 0.8F); + --stack.stackSize; + } + + return true; + } + else + { + return false; + } + } +} diff --git a/tconstruct/items/blocks/LavaTankItemBlock.java b/tconstruct/items/blocks/LavaTankItemBlock.java index 47c47046..cb76c1e2 100644 --- a/tconstruct/items/blocks/LavaTankItemBlock.java +++ b/tconstruct/items/blocks/LavaTankItemBlock.java @@ -1,7 +1,11 @@ package tconstruct.items.blocks; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.MathHelper; public class LavaTankItemBlock extends ItemBlock @@ -25,4 +29,17 @@ public class LavaTankItemBlock extends ItemBlock int pos = MathHelper.clamp_int(itemstack.getItemDamage(), 0, blockType.length - 1); return (new StringBuilder()).append("LavaTank.").append(blockType[pos]).toString(); } + + public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4) + { + if (stack.hasTagCompound()) + { + NBTTagCompound liquidTag = stack.getTagCompound().getCompoundTag("Fluid"); + if (liquidTag != null) + { + list.add("Contains "+liquidTag.getString("FluidName")); + list.add(liquidTag.getInteger("Amount")+" mB"); + } + } + } } diff --git a/tconstruct/items/blocks/RedstoneMachineItem.java b/tconstruct/items/blocks/RedstoneMachineItem.java index 4d14fb1a..e3722a7a 100644 --- a/tconstruct/items/blocks/RedstoneMachineItem.java +++ b/tconstruct/items/blocks/RedstoneMachineItem.java @@ -1,7 +1,11 @@ package tconstruct.items.blocks; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.MathHelper; public class RedstoneMachineItem extends ItemBlock @@ -25,4 +29,47 @@ public class RedstoneMachineItem extends ItemBlock int pos = MathHelper.clamp_int(itemstack.getItemDamage(), 0, blockType.length - 1); return (new StringBuilder()).append("block.").append(blockType[pos]).toString(); } + + @Override + public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4) + { + if (stack.hasTagCompound() && stack.getItemDamage() == 0) + { + NBTTagCompound contentTags = stack.getTagCompound().getCompoundTag("Contents"); + if (contentTags != null) + { + ItemStack contents = ItemStack.loadItemStackFromNBT(contentTags); + if (contents != null) + { + list.add("Inventory: " + contents.getDisplayName()); + list.add("Amount: " + contents.stackSize); + } + } + NBTTagCompound camoTag = stack.getTagCompound().getCompoundTag("Camoflauge"); + if (camoTag != null) + { + ItemStack camo = ItemStack.loadItemStackFromNBT(camoTag); + if (camo != null) + list.add("Camoflauge: " + camo.getDisplayName()); + } + + if (stack.getTagCompound().hasKey("Placement")) + { + String string = getDirectionString(stack.getTagCompound().getByte("Placement")); + list.add("Placement Direction: " + string); + } + } + } + + String getDirectionString(byte key) + { + if (key == 0) + return ("Up"); + if (key == 1) + return ("Right"); + if (key == 2) + return ("Down"); + + return "Left"; + } } diff --git a/tconstruct/items/blocks/StainedGlassClearPaneItem.java b/tconstruct/items/blocks/StainedGlassClearPaneItem.java index ded8851c..1e564beb 100644 --- a/tconstruct/items/blocks/StainedGlassClearPaneItem.java +++ b/tconstruct/items/blocks/StainedGlassClearPaneItem.java @@ -23,6 +23,6 @@ public class StainedGlassClearPaneItem extends ItemBlock public String getUnlocalizedName (ItemStack itemstack) { int pos = MathHelper.clamp_int(itemstack.getItemDamage(), 0, blockType.length - 1); - return (new StringBuilder()).append("block.stainedglass.pane.").append(blockType[pos]).toString(); + return (new StringBuilder()).append("block.stainedglass.").append(blockType[pos]).append(".pane").toString(); } } diff --git a/tconstruct/landmine/block/BlockLandmine.java b/tconstruct/landmine/block/BlockLandmine.java index 9a231974..40b3042a 100644 --- a/tconstruct/landmine/block/BlockLandmine.java +++ b/tconstruct/landmine/block/BlockLandmine.java @@ -488,7 +488,8 @@ public class BlockLandmine extends BlockContainer { return false; } - @Override + @SuppressWarnings("incomplete-switch") + @Override public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4) { int l = par1IBlockAccess.getBlockMetadata(par2, par3, par4); int i1 = l & 7; diff --git a/tconstruct/library/tools/AbilityHelper.java b/tconstruct/library/tools/AbilityHelper.java index 7496e5c5..c80a01f6 100644 --- a/tconstruct/library/tools/AbilityHelper.java +++ b/tconstruct/library/tools/AbilityHelper.java @@ -388,32 +388,33 @@ public class AbilityHelper if (!tags.hasKey("charge")) return false; + NBTTagCompound toolTag = stack.getTagCompound().getCompoundTag("InfiTool"); int charge = tags.getInteger("charge"); - int durability = tags.getInteger("Damage"); - float shoddy = tags.getFloat("Shoddy"); + int durability = toolTag.getInteger("Damage"); + float shoddy = toolTag.getFloat("Shoddy"); - float mineSpeed = tags.getInteger("MiningSpeed"); + float mineSpeed = toolTag.getInteger("MiningSpeed"); int heads = 1; if (tags.hasKey("MiningSpeed2")) { - mineSpeed += tags.getInteger("MiningSpeed2"); + mineSpeed += toolTag.getInteger("MiningSpeed2"); heads++; } if (tags.hasKey("MiningSpeedHandle")) { - mineSpeed += tags.getInteger("MiningSpeedHandle"); + mineSpeed += toolTag.getInteger("MiningSpeedHandle"); heads++; } if (tags.hasKey("MiningSpeedExtra")) { - mineSpeed += tags.getInteger("MiningSpeedExtra"); + mineSpeed += toolTag.getInteger("MiningSpeedExtra"); heads++; } float trueSpeed = mineSpeed / (heads * 100f); - float stonebound = tags.getFloat("Shoddy"); + float stonebound = toolTag.getFloat("Shoddy"); float bonusLog = (float) Math.log(durability / 72f + 1) * 2 * stonebound; trueSpeed += bonusLog; diff --git a/tconstruct/util/PHConstruct.java b/tconstruct/util/PHConstruct.java index 4b469928..a5aaa2e1 100644 --- a/tconstruct/util/PHConstruct.java +++ b/tconstruct/util/PHConstruct.java @@ -77,7 +77,7 @@ public class PHConstruct blueSlime = config.get("Mob Spawning", "Activate Blue Slime Spawns", true).getBoolean(true); blueSlimeWeight = config.get("Mob Spawning", "Spawn Weight for Blue Slime", 6).getInt(6); - woodCrafter = config.getBlock("Wood Tool Station", 1471).getInt(1471); + woodStation = config.getBlock("Wood Tool Station", 1471).getInt(1471); heldItemBlock = config.getBlock("Held Item Block", 1472).getInt(1472); lavaTank = config.getBlock("Lava Tank", 1473).getInt(1473); smeltery = config.getBlock("Smeltery", 1474).getInt(1474); @@ -98,17 +98,15 @@ public class PHConstruct speedBlock = config.getBlock("Speed Block", 1489).getInt(1489); landmine = config.getBlock("Landmine", 1470).getInt(1470); - barricade = config.getBlock("Barricade", 1469).getInt(1469); toolForge = config.getBlock("Tool Forge", 1468).getInt(1468); multiBrickFancy = config.getBlock("Multi Brick Fancy", 1467).getInt(1467); - - /*public static int moltenSilver; //Thermal Expansion - public static int moltenLead; - public static int moltenNickel; - public static int moltenPlatinum; - public static int moltenInvar; - public static int moltenElectrum;*/ - + + barricadeOak = config.getBlock("Oak Barricade", 1469).getInt(1469); + barricadeSpruce = config.getBlock("Spruce Barricade", 1482).getInt(1482); + barricadeBirch = config.getBlock("Birch Barricade", 1483).getInt(1483); + barricadeJungle = config.getBlock("Jungle Barricade", 1487).getInt(1487); + + //Thermal Expansion moltenSilver = config.getBlock("Molten Silver", 3195).getInt(3195); moltenLead = config.getBlock("Molten Lead", 3196).getInt(3196); moltenNickel = config.getBlock("Molten Nickel", 3197).getInt(3197); @@ -146,6 +144,9 @@ public class PHConstruct searedSlab = config.getBlock("Seared Slab", 3230).getInt(3230); speedSlab = config.getBlock("Speed Slab", 3231).getInt(3231); //grassSlab = config.getBlock("Grass Slab", 3230).getInt(3230); + + punji = config.getBlock("Punji", 3232).getInt(3232); + woodCrafter = config.getBlock("Crafting Station", 3233).getInt(3233); /*golemCore = config.getBlock("Golem Core", 1481).getInt(1481); golemHead = config.getBlock("Golem Head", 1482).getInt(1482);*/ @@ -335,9 +336,11 @@ public class PHConstruct } //Blocks - public static int woodCrafter; + public static int woodStation; public static int toolForge; public static int heldItemBlock; + public static int woodCrafter; + public static int ores; public static int lavaTank; public static int smeltery; @@ -361,7 +364,11 @@ public class PHConstruct //Traps public static int landmine; - public static int barricade; + public static int punji; + public static int barricadeOak; + public static int barricadeSpruce; + public static int barricadeBirch; + public static int barricadeJungle; //InfiBlocks public static int speedBlock; diff --git a/tconstruct/util/TEventHandler.java b/tconstruct/util/TEventHandler.java index ed7e0073..434b8f3d 100644 --- a/tconstruct/util/TEventHandler.java +++ b/tconstruct/util/TEventHandler.java @@ -479,6 +479,12 @@ public class TEventHandler @ForgeSubscribe public void registerOre (OreRegisterEvent evt) { + String ingot = evt.Name.toLowerCase(); + if (ingot.contains("ingot")) + { + TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(TContent.moltenAlubrassFluid, TConstruct.ingotLiquidValue), evt.Ore, false, 50); + TConstruct.tableCasting.addCastingRecipe(new ItemStack(TContent.metalPattern, 1, 0), new FluidStack(TContent.moltenGoldFluid, TConstruct.ingotLiquidValue * 2), evt.Ore, false, 50); + } if (evt.Name == "battery") TConstruct.content.modE.batteries.add(evt.Ore); diff --git a/tconstruct/util/network/TPacketHandler.java b/tconstruct/util/network/TPacketHandler.java index dbfb7773..e7bd562d 100644 --- a/tconstruct/util/network/TPacketHandler.java +++ b/tconstruct/util/network/TPacketHandler.java @@ -14,6 +14,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.world.World; import net.minecraftforge.common.DimensionManager; import tconstruct.TConstruct; +import tconstruct.blocks.logic.DrawbridgeLogic; import tconstruct.blocks.logic.ToolForgeLogic; import tconstruct.blocks.logic.ToolStationLogic; import tconstruct.library.blocks.InventoryLogic; @@ -120,6 +121,22 @@ public class TPacketHandler implements IPacketHandler break; } } + + else if (packetID == 5) //Drawbridge + { + int dimension = inputStream.readInt(); + World world = DimensionManager.getWorld(dimension); + int x = inputStream.readInt(); + int y = inputStream.readInt(); + int z = inputStream.readInt(); + TileEntity te = world.getBlockTileEntity(x, y, z); + + byte direction = inputStream.readByte(); + if (te instanceof DrawbridgeLogic) + { + ((DrawbridgeLogic) te).setPlacementDirection(direction); + } + } else if (packetID == 10) //Double jump { diff --git a/tconstruct/util/player/FakePlayerLogic.java b/tconstruct/util/player/FakePlayerLogic.java new file mode 100644 index 00000000..2e9c2392 --- /dev/null +++ b/tconstruct/util/player/FakePlayerLogic.java @@ -0,0 +1,21 @@ +package tconstruct.util.player; + +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; +import net.minecraftforge.common.FakePlayer; +import tconstruct.library.blocks.InventoryLogic; + +public class FakePlayerLogic extends FakePlayer +{ + InventoryLogic logic; + public FakePlayerLogic(World world, String name, InventoryLogic logic) + { + super(world, name); + this.logic = logic; + } + + public ChunkCoordinates getPlayerCoordinates() + { + return new ChunkCoordinates(logic.xCoord, logic.yCoord, logic.zCoord); + } +}