[Tut]Tworzenie Modów do Minecrafta

ElDorado123 · 29 Listopada 2012

Witam ostatnio dostrzegłem, że na forach polskich brakuje tutorialów na temat tworzeniu modów do minecrafta

nie martwcie się zrobię dla was ten tutorial. Do stworzenia własnego moda potrzeba:

-Chociaż minimalna znajomość javy

-Znajomość języka angielskiego

-I oczywiście dużo chęci

1.Instalujemy Programy

1.Wchodzimy na Stronę tu i pobieramy Odpowiedni JDK

2.Instalujemy Nasz JDK

3.Klikamy Na Mój Kom... Prawym Przyciskiem i wybieramy Właściwości|>Zaawansowane|>Zmienne środowiskowe i w patch wklejamy ścieżkę do naszej javy

4.Wchodzimy w Start|>Uruchom i Wpisujemy cmd i klikamy OK i wpisujemy javac i jeśli wyświetliły wam się że Nie zostało zozpoznane to zrobiliście coś źle

5.Pobieramy ModLoader do Minecraft 1.3.1 tu

6.Pobieramy MCP 7.x tu

7.Wypakowujemy do do jakiegoś folderu i Otwieramy Uruchom i wpisujemy %appdata% i OK i w .minecraft są 2 Foldery Bin i resources i kopiujemy to do folderu jars w mcp 7.x

8.Otwieramy Folder Bin i Otwieramy minecraft.jar za Pomocą WinRAR Usuwamy folder META-INF i kopiujemy Modloader do minecraft.jar

9.Pobieramy minecraft_server.jar z Minecraft.net i Kopiujemy go do folderu bin w mcp

10.i Klikamy na decomplice i czekamy aż zakończy dekomplikoać

11.Pobieramy Eclipse Classic 4.2 tu

12.Otwieramy Eclipse i wyskoczy okienko żebyśmy wybrali jakiś folder wchodzimy w mcp i wybieramy eclipse(folder)

Dobra Przypuśćmy Ze już zrobiliśmy jakiegoś moda i teraz w menu u góry jest zielony przycisk(Run As) i Otwiera nam się minecraft wraz z modem

Jezu Ale się Napisałem

2.Item

Witam was w Następnej Lekcji w której Napiszemy własny Item

To Zaczynamy

Wzór Pliku Gównego(mod_NAZWAMODA)


package net.minecraft.src;
public class mod_NAZWAMODA extends BaseMod
{
public static Item NAZWAITEMU = new Item(ID).setItemName("NAZWAITEMU");
public String getVersion()
{
return "WERSJA";
}
public void load(){}
public mod_NAZWAMODA()
{
NAZWAPRZEDMIOTU.iconIndex = ModLoader.addOverride("/gui/items.png", "/Ścieszka");
ModLoader.addName(NAZWAITEMU, "NAZWAWGRZE");
}
}

WERSJA - Zastąp Wersją Moda

Aby Dowiedzieć się co to dalej znaczy przeczytaj całą Lekcje

w mod_MOD

piszemy

public static Item Nazwa = new Item(ID).setItemName("NAZWAITEMU");

Nazwa - Zastąp Nazwą Itemu(Później będzie nam to potrzebne)

ID- Zastąp ID zacznij od 501

NAZWAITEMU- Zastąp Nazwą Itemu

Teraz w funkcji mod_NAZWAMODA()

piszemy

ModLoader.addName(Nazwa1, "NAZWAWGRZE");
Nazwa1.iconIndex = ModLoader.addOverride("/gui/items.png", "Ścieżka");

Nazwa1 - Zastąp to co wpisałeś w publicu(Jest To Nazwa)

NAZWAWGRZE - Zastąp to jak będzie się nazywało w grze

Ścieżka - Zastąp Ścieżką do Textury Itemu

Gotowy Kod:


package net.minecraft.src;
public class mod_Frugo extends BaseMod
{
public static Item frugo = new Item(500).setItemName("Frugo");
public String getVersion()
{
return "1.0";
}
public void load(){}
public mod_Frugo()
{
pilot.iconIndex = ModLoader.addOverride("/gui/items.png", "/frugo.png");
ModLoader.addName(frugo, "Butelka Frugo");
}
}

3.Nowy Blok

Witam Dziś Napiszemy sobie nasz pierwszy blok

to zaczynamy

dodam jeszcze że piszę tą lekcje 2 raz bo nie wiem dlaczego ale strona mi się cofnęła

Tworzymy nasz plik główny czyli mod_NAZWAMODA pamiętamy aby na początku było mod_

NAZWAMODA - Zastąp Nazwą Moda

Wzór tego pliku


package net.minecraft.src;

public class mod_NAZWAMODA extends BaseMod
{
public static Block NAZWABLOKU = new BlockNAZWABLOKUPLIKU(ID, 0).setBlockName("NAZWABLOKU").setHardness(TWARDOŚĆBLOKU).setResistance(ODPORNOŚĆBLOKU);
public String getVersion()
{
return "WERSJA";
}
public void load() {}
public mod_NAZWAMODA()
{
NAZWABLOKU.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/ŚĆIEŻKA");
ModLoader.registerBlock(NAZWABLOKU);
ModLoader.addName(NAZWABLOKU, "NAZWAWGRZE");
}
}

NAZWAMODA - Zastąp swoją nazwą moda

NAZWABLOKU - Zastąp nazwą bloku

NAZWABLOKUPLIKU - Zastąp nazwą jak bendzie się nazywać

ID - Zastąp id bloku ja zaczynałem od 156

TWARDOŚĆBLOKU - jest to jak długo będziemy kopać nasz Blok. Kamień 1.5F . Na Końcu musi być duże F

ODPORNOŚĆBLOKU - Jest to siła za jaką wybuch może zniszczyć blok

WERSJA - Zastąp Wersją moda lub minecraft'a

ŚCIEŻKA - zastąp ścieżką do textury bloku np : craftsite/blok.png (na końcu musi być zawsze format .png)

NAZWAWGRZE - Odpowiada za dodanie do gry nazwy bloku(zastąp własną nazwą bloku)

Objaśnienie:

ModLoader.registerBlock(NAZWABLOKU); - Odpowiada za zarejestrowanie bloku w grze

ModLoader.addName(NAZWABLOKU, "NAZWAWGRZE"); - Odpowiada za dodanie do gry nazwy

OK Teraz stworzymy plik bloku BlockNAZWABLOKU

Wzór pliku:


package net.minecraft.src;
import java.util.Random;
public class BlockNAZWABLOKU extends Block
{
public BlockNAZWABLOKU(int i, int j)
{
super(i, j, Material.MATERIAŁ);
Creative
}
public int idDropped(int i, Random j, int k)
{
return mod_NAZWAMODA.NAZWA.blockID;
}
}

NAZWABLOKU - zastąp nazwą pliku

MATERIAŁ - Jest to materiał bloku : rock-Kamień, wood- drewno, glass-Szkło, sand-piasek, cloth - wełna

NAZWA - jest to nazwa itemu który ma wypaść z bloku którego stworzyliśmy w cz.2 jeśli nie chcemy żeby wypadało usuń public int idDropped cały

Creative - zastąp gdzie ma się znaleść blok Zakładka Blok ("func_71849_a(CreativeTabs.field_78030_ ;")

To już koniec tej Lekcji o Bloku

Gratulacje Stworzyłeś swój własny Blok

Gotowe Pliki :

mod_Aluminium.java


package net.minecraft.src;
public class mod_Aluminium extends BaseMod
{
public static Block Aluminium = new BlockAluminium(131, 0).setBlockName("Aluminium").setHardness(0.5F).setResistance(3F);
public String getVersion()
{
return "1.0";
}
public void load() {}
public mod_Aluminium()
{
Alumnium.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/Mod/blockAluminium.png");
ModLoader.registerBlock(Aluminium);
ModLoader.addName(Aluminium, "Aluminium Block");
}
}

BlockAluminium.java


package net.minecraft.src;
public class BlockAluminium extends Block
{
public BlockAluminium(int i, int j)
{
super(i, j, Material.glass);
func_71849_a(CreativeTabs.field_78030_;
}
}

4.Własne Jedzenie

Witam W Części 4 dziś zrobimy własne jedzenie

To Zaczynamy

To Wklejamy do naszego mod_NAZWAMODA:

public static Item NAZWAJEDZENIA = new ItemFood(ID, ŻYCIE, OSWOJĆ).setItemName("NAZWAJEDZENIA");

NAZWAJEDZENIA - zastąp nazwą swego żarcia

ID - jest to id naszego Itemu (zacznij od 157)

ŻYCIE - Jest to to ile dodaje nam żyć (1 to 2 serduszka człowiek ma 20 żyć)

OSWOJĆ - To Odpowiada za to czy wilki można tym oswoić czy nie (false że nie, true że tak)

teraz w funkcji load() w naszym pliku(mod_NAZWAMODA)

piszemy takie coś:

ModLoader.addName(NAZWAJEDZENIA, "NAZWAWGRZE");

to odpowiada za dodanie nazwy w grze

NAZWAWGRZE - Podaj tu swoją nazwe jedzenia która będzie pokazana w grze

Jeszcze czeba dokleić to też w load()

NAZWAJEDZENIA.iconIndex = ModLoader.addOverride("/gui/items.png", "/ŚCIEŻKA");

To odpowiada za dodanie do gry textury naszego jedzenia

ŚCIEŻKA - zastąp ścieżką do tekstury jedzenia(np: "/Craftsite/Arbuz.png" na końcu pliku musi być rozszerzenie PNG)

To Tyle Jak Na Ten Poradnik Może Jeszcze Dziś Zrobie Następny Ale Zobacze Czy Będę miał czas

5.Efekty Miksturek

Witam dziś pokaże wam jak wykorzystać efekty mikstur w modzie Dlaczego dziś taka Lekcja dlatego że nie chcem mi się pisać o rudach ale one będą w cz.6 i mam ograniczenie neta

To Zaczynamy

Przed setItemName() dodajemy

.setPotionEffect(Potion.EFEKT.id, CZASMIKSTUREK, ULEPSZENIE, SZANSA)

EFEKT - zastąp efektem (np .regeneration odpowiada za regeneracje życia)

CZASMIKSTUREK - to ile efekt będzie działał podawaj w sekundach

ULEPSZENIE - ulepszenie miksturki polecam wpisać 0

SZANSA - jest to szansa na wystąpienie efektu(jeżeli chcemy aby efekt był cały czas po zjedzeniu, wypiciu To Wpisujemy 100)

To Na Tyle W Tej Lekcji i nie wiem kiedy zrobię następną bo zaczyna się rok szkolny i net mi się zepsuł a teraz pisze to na necie mojej cioci której nie ma teraz ale jak bedzie to nie da mi wejść

6.Własna Ruda

Witam W Kolejnej Części Tuta Dziś Wygenerujemy sobie naszą własną Rude

Pierw Musimy stworzyć Blok (Zobacz w części "3.Własny Blok" aby stworzyć go)

Ok Importujemy Klasę Random więc po

package net.minecraft.src;

Wklejamy Random

import java.util.Random;

Ok Teraz Wklejmy kod na generowanie naszej rudy

public void generateSurface(World world, Random random, int i, int j)
{
for (int k = 0; k < 3; k++)
{
int x = i + random.nextInt(RZADKOŚĆ);
int y = random.nextInt(POZIOM);
int z = j + random.nextInt(RZADKOŚĆ);
(new WorldGenMinable(BLOK.blockID, ILOSC)).generate(world, random, x, y, z);
}
}

RZADKOŚĆ - Jest to jak żadko będą się generowały rudy Ustaw Domyślnie 16

POZIOM - Jest to poziom do jakiego ruda będzie się generowała zaczyna od 0

BLOK - Jest to nasz blok stworzony w cz.3 Własny Blok

ILOŚĆ - Zamień na Ilość wygenerowanych rud koło siebie

Możemy Też Zrobić tak że zmienimy Minimalny Poziom Rudy(np: Generuje się od 50 do 100)

Zamień to

int y = random.nextInt(POZIOM);

Na to

int y = MINIMALNY + random.nextInt(MAKSYMALNY);

MINIMALNY - Jest to Minimalny poziom na jakim będzie się generowała ruda

MAKSYMALNY - Jest to Maksymalny poziom na jakim będzie się generowała ruda

Możemy zrobić tak że ruda będzie się generowała w Netherze

public void generateNether(World world, Random random, int randXCoord, int randZCoord)
{
for (int oreFrequency = 0; oreFrequency < 3; oreFrequency++)
{
int xCoord = randXCoord + random.nextInt(RZADKOŚĆ);
int yCoord = MINIMALNY + random.nextInt(MAKSYMALNY);
int zCoord = randZCoord + random.nextInt(RZADKOŚĆ);
(new WorldGenMinableNether(BLOK.blockID, ILOŚĆ)).generate(world, random, xCoord, yCoord, zCoord);
}
}

Wyjaśnienie tego macie wyżej

OK Jeśli Tworzymy rude w netherze to tworzymy nowy plik " WorldGenMinableNether"

package net.minecraft.src;
import java.util.Random;
public class WorldGenMinableNether extends WorldGenerator
{
/** The block ID of the ore to be placed using this generator. */
private int minableBlockId;
/** The number of blocks to generate. */
private int numberOfBlocks;
public WorldGenMinableNether(int par1, int par2)
{
this.minableBlockId = par1;
this.numberOfBlocks = par2;
}
public boolean generate(World par1World, Random par2Random, int par3, int par4, int par5)
{
float var6 = par2Random.nextFloat() * (float)Math.PI;
double var7 = (double)((float)(par3 + 8) + MathHelper.sin(var6) * (float)this.numberOfBlocks / 8.0F);
double var9 = (double)((float)(par3 + 8) - MathHelper.sin(var6) * (float)this.numberOfBlocks / 8.0F);
double var11 = (double)((float)(par5 + 8) + MathHelper.cos(var6) * (float)this.numberOfBlocks / 8.0F);
double var13 = (double)((float)(par5 + 8) - MathHelper.cos(var6) * (float)this.numberOfBlocks / 8.0F);
double var15 = (double)(par4 + par2Random.nextInt(3) - 2);
double var17 = (double)(par4 + par2Random.nextInt(3) - 2);
for (int var19 = 0; var19 <= this.numberOfBlocks; ++var19)
{
double var20 = var7 + (var9 - var7) * (double)var19 / (double)this.numberOfBlocks;
double var22 = var15 + (var17 - var15) * (double)var19 / (double)this.numberOfBlocks;
double var24 = var11 + (var13 - var11) * (double)var19 / (double)this.numberOfBlocks;
double var26 = par2Random.nextDouble() * (double)this.numberOfBlocks / 16.0D;
double var28 = (double)(MathHelper.sin((float)var19 * (float)Math.PI / (float)this.numberOfBlocks) + 1.0F) * var26 + 1.0D;
double var30 = (double)(MathHelper.sin((float)var19 * (float)Math.PI / (float)this.numberOfBlocks) + 1.0F) * var26 + 1.0D;
int var32 = MathHelper.floor_double(var20 - var28 / 2.0D);
int var33 = MathHelper.floor_double(var22 - var30 / 2.0D);
int var34 = MathHelper.floor_double(var24 - var28 / 2.0D);
int var35 = MathHelper.floor_double(var20 + var28 / 2.0D);
int var36 = MathHelper.floor_double(var22 + var30 / 2.0D);
int var37 = MathHelper.floor_double(var24 + var28 / 2.0D);
for (int var38 = var32; var38 <= var35; ++var38)
{
double var39 = ((double)var38 + 0.5D - var20) / (var28 / 2.0D);
if (var39 * var39 < 1.0D)
{
for (int var41 = var33; var41 <= var36; ++var41)
{
double var42 = ((double)var41 + 0.5D - var22) / (var30 / 2.0D);
if (var39 * var39 + var42 * var42 < 1.0D)
{
for (int var44 = var34; var44 <= var37; ++var44)
{
double var45 = ((double)var44 + 0.5D - var24) / (var28 / 2.0D);
if (var39 * var39 + var42 * var42 + var45 * var45 < 1.0D | par1World.getBlockId(var38, var41, var44) == Block.netherrack.blockID)
{
par1World.setBlock(var38, var41, var44, this.minableBlockId);
}
}
}
}
}
}
}
return true;
}
}

To Nic Nie Zmieniamy

Ok To Już Wszystko Zrobiliście Własną rude w Świecie/Netherze

7.Własny Przepis/Crafting

Witam Dziś Zrobimy Własny Przepis/Crafting Możemy to wykorzystać w Bloku,Item i innej rzeczy.

To Wklej do "public void load();"

ModLoader.addRecipe(new ItemStack(ITEM, ILOŚĆ), new Object[]
{
"REC", "REC", " REC", 'REC', ZCZEGO
});

ITEM - zastąp tym co wychodzi po craftingu(np: Item.coal) Jeśli chcemy żeby wykorzystać coś z moda to wpisz mod_NAZWAMODA.NAZWAITEMU/BLOKU

ILOŚĆ - Tu Wpisz Ilość Wyniku

mod_NAZWAMODA - Wpisz Nazwe Moda

ZCZEGO - Jest to zczego będzie się robić tą rzecz(np: Item.sing)

REC - Tu zastąp to jakomś bylejaką literą lub Cyfrą

NAZWAITEM - to nazwa itemu w modzie lub bloku

Jeśli Usuniemy Jedną "REC", to nic się nie stanie tylko będzie się to robiło z mniej materiału

Ok teraz pokaże jak zrobić przepalanie Itemu/Bloku

ModLoader.addSmelting(ID, new ItemStack(WYNIK, ILOŚĆ), EXP);

ID - tu wpisz id bloku/przedmiotu którego można przepalić

WYNIK - zastąp to co ma wyjść po przepalaniu

ILOŚĆ - tu wpisz ile ma wyjść wyniku

EXP - jest to exp wypadający za przepalanie(np wpisz: 10)

8.Mob

Witam w kolejnej części poradnika dziś zrobimy własnego moba

to zaczynamy

Pierw importujemy Klase Map


import java.util.Map;

ok i w funkcji public void load() dodajemy:


ModLoader.registerEntityID(EntityNAZWA.class, "NAZWAMOBA", ID);
ModLoader.addSpawn(EntityNAZWA.class, SZANSA, MINIMANLY, MAKSYMALNY, EnumCreatureType.TYPMOBA);

NAZWA - Zastąp nazwą moba

NAZWAMOBA - Tu wpisz własną nazwę moba

ID - Tu wpisz id moba zacznij od 50 aż do 150

SZANSA - Wpisz tu szanse wystąpienia moba od 1 do 15

MINIMALNY - Zastąp minimalną liczbe zespawnowanych mobów w chunku

MAKSYMALNY - Zastąp maksymalną liczbe zespawnowanych mobów w chunku<p>TYPMOBA to typ moba:

creature - mob pasywny(nigdy cię nie atakuje, spawnuje się tylko w świetle)

watercreature - mob pasywny spawnuje się w wodzie np: jak kałamarnica

monster - potwór(spawnuje się w nocy i atakuje)np: Zombie

Teraz dodajmy nową funkcje:


public void addRenderer(Map map)
{
map.put(EntityNAZWA.class, new RenderBiped(new ModelBiped(), 0.5F));
}

Musimy stworzyć nowy plik o nazwie EntityNAZWAMOBA wzór:


package net.minecraft.src;


import java.util.Random;

public class EntityNAZWAMOBA extends EntityMOB
{
public EntityNAZWAMOBA(World world)
{
super(world);
texture = "ŚCIEŻKA";
moveSpeed = SZYBKOŚĆ;
getNavigator().setAvoidsWater(true);
LISTA
}
public int getMaxHealth()
{
return ŻYCIE;
}

public boolean isAIEnabled()
{
return true;
}

protected String getLivingSound()
{
return "mob.MOB.default";
}
protected String getHurtSound()
{
return "mob.MOB.defaulthurt";
}
protected String getDeathSound()
{
return "mob.MOB.defaultdeath";
}
protected int getDropItemId()
{
return DROP.shiftedIndex;
}

protected boolean canDespawn()
{
return ZNIKANIE;
}
}

-MOB - Zastąp typem moba

-EntityAnimal - mob pasywny

-EntityMob - mob agresywny

-EntityWaterMob - pasywny mob wodny

NAZWAMOBA - zastąp nazwą moba

ŚCIEŻKA - Tu wpisz ścieżke do textury moba zobacz textury jakiegoś moba w folderze mob w minecraft.jar

SZYBKOŚĆ - Tu wpisz szybkość moba człowiek ma 1.5F a krowa 0.5F na końcu musi być duże F

LISTA - Tu wpisz liste umięjetności moba :

Wzór

tasks.addTask(LICZBA, new UMIEJĘTNOŚĆ(INNE));

LICZBA - jest to liczba umięjetności zacznij od 0

UMIEJĘTNOŚĆ - zastąp nazwą umięjetności moba

INNE - tu wpisz parametry umiejętności moba

Ok to lista tych umiejętności:

-EntityAIWander(this, 0.25F) - losowe chodzenie moba mają to wszystkie podstawowe moby
-EntityAISwimming(this) - pływanie(jeśli tego nie ma i mob wejdzie do wody to utonie )
-EntityAIPanic(this, 0.38F) - Jest to panika moba(jak uderzysz go to zacznie uciekać (ma to krowa))
-EntityAITempt(this, 0.25F, ITEM, false) - Jest to chodzenie za wybtranym Itemem. ITEM - Zastąp to nazwą itemu za którym ma chodzić mob
-EntityAIFollowParent(this, 0.28F) - rozmnażanie wybranym itemem w EntityAITempt. Jest to potrzebne do rozmnażania
-EntityAIMate(this, 0.25F) - potrzebne do rozmnażania
-EntityAIOpenDoor(this, true) - jeśli to będzie miał mob to będzie mógł rozwalać drzwi

ok to były umiejętności teraz jeśli mob ma się rozmnażać to musimy dodać nową funkcje w EntityNAZWA.java:


public EntityAnimal spawnBabyAnimal(EntityAnimal par1EntityAnimal)
{
return new EntityNAZWAMOBA(worldObj);
}

Aha i mob musi być mobem pasywnym

Ok to już na tyle w tej lekcji Teraz jeszcze pokaże wzór moba:

mod_Mumia.java


package net.minecraft.src;

import java.util.Map;


public class mod_Mumia extends BaseMod
{
public void load()
{
ModLoader.registerEntityID(EntityMumia.class, "Mumia", ModLoader.getUniqueEntityId());
ModLoader.addSpawn(EntityMumia.class, 12, 4, 4, EnumCreatureType.monster);
}

public void addRenderer(Map map)
{
map.put(EntityMumia.class, new RenderBiped(new ModelBiped(), 0.5F));
}

public String getVersion()
{
return "v1.0";
}

public mod_Mumia()
{

}
}

EntityMumia.java:


package net.minecraft.src;

import java.util.Random;

public class EntityMumia extends EntityAnimal
{
public EntityMumia(World world)
{
super(world);
texture = " mob\mobmumia.png";
moveSpeed = 1F;
getNavigator().func_48664_a(true);
tasks.addTask(0, new EntityAITempt(this, 0.25F, Item.wheat.shiftedIndex, false));
tasks.addTask(1, new EntityAIFollowParent(this, 0.28F));
tasks.addTask(2, new EntityAIMate(this, 0.25F));
tasks.addTask(3, new EntityAISwimming(this));
tasks.addTask(4, new EntityAIPanic(this, 0.38F));
tasks.addTask(5, new EntityAIWander(this, 0.25F));
}
public int getMaxHealth()
{
return 5;
}

public boolean isAIEnabled()
{
return true;
}

protected String getLivingSound()
{
return "mob.Pig.default";
}
protected String getHurtSound()
{
return "mob.Pig.defaulthurt";
}
protected String getDeathSound()
{
return "mob.Pig.defaultdeath";
}
protected int getDropItemId()
{
return Item.diamond.shiftedIndex;
}

protected boolean canDespawn()
{
return false;
}

public EntityAnimal spawnBabyAnimal(EntityAnimal par1EntityAnimal)
{
return new EntityPig(worldObj);
}
}

Narazie Mob Będzie miał model człowieka ale będzie niedługo o tym lekcja jak zrobić własny model moba

9.Narzędzia

Witam, w kolejnej części tutoriala, dziś zrobimy narzędzia

to zaczynamy

pierw w clasie mod_NAZWAMODA piszemy

public static Item NAZWA = new ItemTYPJAKIE(ID, EnumTYPToolMaterial.TYP2).setItemName("NAZWANARZĘDZIA");

TYPJAKIE - TYP zastąp typem narzędzia a JAKIE zastąp Co to ma być za narzędzie(np: Kilof-Pickaxe, Miecz-Sword, Motyka-Hoe)

ID - jest to id narzędzia zacznij od 200 a zakończ na 300

TYP - Typ Narzędzia

TYP2 - tu wpisz typ narzędzia z pliku EnumTYPToolMaterial którą zaraz stworzysz TYP NAPISZ DUŻYMI LITERAMI

NAZWANARZĘDZIA - tu wpisz jakąś nazwę narzędzia

Ok teraz stwórz nowy plik o nazwie EnumTYPToolMaterial


package net.minecraft.src;

public enum EnumTYPToolMaterial
{
TYP2( POZ, UZYĆ, MOC, ŻYĆ, 14);

private final int harvestLevel;
private final int maxUses;
private final float efficiencyOnProperMaterial;
private final int damageVsEntity;
private final int enchantability;

private EnumTYPToolMaterial(int k, int l, float f, int i1, int j1)
{
harvestLevel = k;
maxUses = l;
efficiencyOnProperMaterial = f;
damageVsEntity = i1;
enchantability = j1;
}

public int getMaxUses()
{
return maxUses;
}

public float getEfficiencyOnProperMaterial()
{
return efficiencyOnProperMaterial;
}

public int getDamageVsEntity()
{
return damageVsEntity;
}

public int getHarvestLevel()
{
return harvestLevel;
}

public int getEnchantability()
{
return enchantability;
}
}

POZ - zastąp poziomem narzędzia poziom znaczy że dany blok (np: Ruda Diamentu) kopie sie odpowiednim narzędziem(np: Diam-Żelazny Kilof)

Poziomy-

-drewniane - 0

-kamienne - 1

-żelaznne - 2

-diamentowe - 3

-złote - 0

UŻYĆ - zastąp ilością użyć(ile razy ma udeżyć żeby zniszczyć narzędzie)

Ilość(nie wiem ile ma kilof diax ale 100 to jest mało 500 to ok tak jak diax narzędzia)

MOC - zastąp mocą narzędzia :

-drewniane - 2F

-kamienne - 4F

-żelaznne - 6F

-diamentowe - 8F

-złote - 12F

ŻYĆ - tu wpisz ile ma odbierać żyć po uderzeniu w moba lub coś innego (jedno serce to 2 człowiek ma 20 żyć)

TYP2 - zastąp typem narzędzia NAPISANYMI DUŻYMI LITERAMI (np: DIAMOND) w następnym tutu pokaże jak zrobić własny model narzędzia

OK teraz możemy stworzyć plik o nazwie ItemTYPPickaxe (Każdy kod jest na inny typ narzędzia)

TYP zastąp typem narzędzia

Oto kod Pliku na Kilof


public class ItemTYPPickaxe extends ItemTYPTool
{
private static Block blocksEffectiveAgainst[];

protected ItemTYPPickaxe(int i, EnumTYPToolMaterial enumTYPtoolmaterial)
{
super(i, 2, enumTYPtoolmaterial, blocksEffectiveAgainst);
}

/**
* Returns if the item (tool) can harvest results from the block type.
*/
public boolean canHarvestBlock(Block block)
{
if (block == Block.obsidian)
{
return toolMaterial.getHarvestLevel() == 3;
}

if (block == Block.blockDiamond || block == Block.oreDiamond)
{
return toolMaterial.getHarvestLevel() == 2;
}

if (block == Block.blockGold || block == Block.oreGold)
{
return toolMaterial.getHarvestLevel() == 2;
}

if (block == Block.blockSteel || block == Block.oreIron)
{
return toolMaterial.getHarvestLevel() == 1;
}

if (block == Block.blockLapis || block == Block.oreLapis)
{
return toolMaterial.getHarvestLevel() == 1;
}

if (block == Block.oreRedstone || block == Block.oreRedstoneGlowing)
{
return toolMaterial.getHarvestLevel() == 2;
}

if (block.blockMaterial == Material.rock)
{
return true;
}
else
{
return block.blockMaterial == Material.iron;
}
}

/**
* Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
* sword
*/
public float getStrVsBlock(ItemStack itemstack, Block block)
{
if (block != null | (block.blockMaterial == Material.iron || block.blockMaterial == Material.rock))
{
return efficiencyOnProperMaterial;
}
else
{
return super.getStrVsBlock(itemstack, block);
}
}

static
{
blocksEffectiveAgainst = (new Block[]
{
Block.cobblestone, Block.stairDouble, Block.stairSingle, Block.stone, Block.sandStone, Block.cobblestoneMossy, Block.oreIron, Block.blockSteel, Block.oreCoal, Block.blockGold,
Block.oreGold, Block.oreDiamond, Block.blockDiamond, Block.ice, Block.netherrack, Block.oreLapis, Block.blockLapis, Block.oreRedstone, Block.oreRedstoneGlowing, Block.rail,
Block.railDetector, Block.railPowered
});
}
}

Kod na Miecz:


package net.minecraft.src;

public class ItemTYPSword extends Item
{
private int weaponDamage;
private final EnumTYPToolMaterial toolMaterial;

public ItemTYPSword(int i, EnumTYPToolMaterial TYPenumtoolmaterial)
{
super(i);
toolMaterial = enumTYPtoolmaterial;
maxStackSize = 1;
setMaxDamage(enumTYPtoolmaterial.getMaxUses());
weaponDamage = 4 +enumTYPtoolmaterial.getDamageVsEntity();
}

/**
* Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
* sword
*/
public float getStrVsBlock(ItemStack itemstack, Block block)
{
return block.blockID == Block.web.blockID ? 15F : 1.5F;
}

/**
* Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
* the damage on the stack.
*/
public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
{
itemstack.damageItem(1, entityliving1);
return true;
}

public boolean onBlockDestroyed(ItemStack itemstack, int i, int j, int k, int l, EntityLiving entityliving)
{
itemstack.damageItem(2, entityliving);
return true;
}

/**
* Returns the damage against a given entity.
*/
public int getDamageVsEntity(Entity entity)
{
return weaponDamage;
}

/**
* Returns True is the item is renderer in full 3D when hold.
*/
public boolean isFull3D()
{
return true;
}

/**
* returns the action that specifies what animation to play when the items is being used
*/
public EnumAction getItemUseAction(ItemStack itemstack)
{
return EnumAction.block;
}

/**
* How long it takes to use or consume an item
*/
public int getMaxItemUseDuration(ItemStack itemstack)
{
return 0x11940;
}

/**
* Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
*/
public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
{
entityplayer.setItemInUse(itemstack, getMaxItemUseDuration(itemstack));
return itemstack;
}

/**
* Returns if the item (tool) can harvest results from the block type.
*/
public boolean canHarvestBlock(Block block)
{
return block.blockID == Block.web.blockID;
}

/**
* Return the enchantability factor of the item, most of the time is based on material.
*/
public int getItemEnchantability()
{
return toolMaterial.getEnchantability();
}
}

Kod na Motyke:

Do motyki trzeba zrobić osobny konstruktor :

public static Item NAZWA = new ItemTYPJAKI(ID, EnumTYPToolMaterial.TYP2).setItemName("NAZWA");

wszystko podałem na początku

ok stwórz plik ItemTYPJAKI


package net.minecraft.src;

public class ItemTYPJAKI extends Item
{
protected EnumTYPToolMaterial field_77843_a;

public ItemTYPJAKI(int par1, EnumTYPToolMaterial typ2)
{
super(par1);
this.field_77843_a = typ2;
this.maxStackSize = 1;
this.setMaxDamage(emerald.getMaxUses());
this.setTabToDisplayOn(CreativeTabs.tabTools);
}

public boolean tryPlaceIntoWorld(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World par3World, int par4, int par5, int par6, int par7, float par8, float par9, float par10)
{
if (!par2EntityPlayer.canPlayerEdit(par4, par5, par6))
{
return false;
}
else
{
int var11 = par3World.getBlockId(par4, par5, par6);
int var12 = par3World.getBlockId(par4, par5 + 1, par6);

if ((par7 == 0 || var12 != 0 || var11 != Block.grass.blockID) && var11 != Block.dirt.blockID)
{
return false;
}
else
{
Block var13 = Block.tilledField;
par3World.playSoundEffect((double)((float)par4 + 0.5F), (double)((float)par5 + 0.5F), (double)((float)par6 + 0.5F), var13.stepSound.getStepSound(), (var13.stepSound.getVolume() + 1.0F) / 2.0F, var13.stepSound.getPitch() * 0.8F);

if (par3World.isRemote)
{
return true;
}
else
{
par3World.setBlockWithNotify(par4, par5, par6, var13.blockID);
par1ItemStack.damageItem(1, par2EntityPlayer);
return true;
}
}
}
}

/**
* Returns True is the item is renderer in full 3D when hold.
*/
public boolean isFull3D()
{
return true;
}

public String func_77842_f()
{
return this.field_77843_a.toString();
}
}

typ2 - tu wpisz małymi literami TYP2 z EnumTYPMaterial

Kod na Łopatę:


package net.minecraft.src;

public class ItemTYPSpade extends ItemTYPTool
{
private static Block blocksEffectiveAgainst[];

public ItemTYPSpade(int i, EnumTYPToolMaterial enumTYPtoolmaterial)
{
super(i, 1, enumTYPtoolmaterial, blocksEffectiveAgainst);
}

/**
* Returns if the item (tool) can harvest results from the block type.
*/
public boolean canHarvestBlock(Block block)
{
if (block == Block.snow)
{
return true;
}
else
{
return block == Block.blockSnow;
}
}

static
{
blocksEffectiveAgainst = (new Block[]
{
Block.grass, Block.dirt, Block.sand, Block.gravel, Block.snow, Block.blockSnow, Block.blockClay, Block.tilledField, Block.slowSand, Block.mycelium
});
}
}

Kod na Siekiery:


package net.minecraft.src;

public class ItemTYPAxe extends ItemTYPTool
{
private static Block blocksEffectiveAgainst[];

protected ItemTYPAxe(int i, EnumTYPToolMaterial enumTYPtoolmaterial)
{
super(i, 3, enumTYPtoolmaterial, blocksEffectiveAgainst);
}

/**
* Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
* sword
*/
public float getStrVsBlock(ItemStack itemstack, Block block)
{
if (block != null | block.blockMaterial == Material.wood)
{
return efficiencyOnProperMaterial;
}
else
{
return super.getStrVsBlock(itemstack, block);
}
}

static
{
blocksEffectiveAgainst = (new Block[]
{
Block.planks, Block.bookShelf, Block.wood, Block.chest, Block.stairDouble, Block.stairSingle, Block.pumpkin, Block.pumpkinLantern
});
}
}

Ok teraz stworzymy nowy plik o nazwie ItemTYPTool

Kod:


package net.minecraft.src;

public class ItemTYPTool extends Item
{
private Block blocksEffectiveAgainst[];
protected float efficiencyOnProperMaterial;
private int damageVsEntity;
protected EnumTYPToolMaterial toolMaterial;

protected ItemTYPTool(int i, int j, EnumTYPToolMaterial enumTYPtoolmaterial, Block ablock[])
{
super(i);
efficiencyOnProperMaterial = 4F;
toolMaterial = enumTYPtoolmaterial;
blocksEffectiveAgainst = ablock;
maxStackSize = 1;
setMaxDamage(enumTYPtoolmaterial.getMaxUses());
efficiencyOnProperMaterial = enumTYPtoolmaterial.getEfficiencyOnProperMaterial();
damageVsEntity = j + enumTYPtoolmaterial.getDamageVsEntity();
}

/**
* Returns the strength of the stack against a given block. 1.0F base, (Quality+1)*2 if correct blocktype, 1.5F if
* sword
*/
public float getStrVsBlock(ItemStack itemstack, Block block)
{
for (int i = 0; i || blocksEffectiveAgainst.length; i++)
{
if (blocksEffectiveAgainst[i] == block)
{
return efficiencyOnProperMaterial;
}
}

return 1.0F;
}

/**
* Current implementations of this method in child classes do not use the entry argument beside ev. They just raise
* the damage on the stack.
*/
public boolean hitEntity(ItemStack itemstack, EntityLiving entityliving, EntityLiving entityliving1)
{
itemstack.damageItem(2, entityliving1);
return true;
}

public boolean onBlockDestroyed(ItemStack itemstack, int i, int j, int k, int l, EntityLiving entityliving)
{
itemstack.damageItem(1, entityliving);
return true;
}

/**
* Returns the damage against a given entity.
*/
public int getDamageVsEntity(Entity entity)
{
return damageVsEntity;
}

/**
* Returns True is the item is renderer in full 3D when hold.
*/
public boolean isFull3D()
{
return true;
}

/**
* Return the enchantability factor of the item, most of the time is based on material.
*/
public int getItemEnchantability()
{
return toolMaterial.getEnchantability();
}
}

TYP - podałem wcześniej

Jeśli chcesz aby dany blok niszczyło się szybciej to znajdź to :


blocksEffectiveAgainst = (new Block[]
{

I dopisz swój blok

10.Dodanie Własnego Paliwa do Piecyka

Witam dziś nudzi mi się więc napisze jeszcze jedną Lekcje "Własne Paliwo"

To zaczynamy:

W głównym pliku moda mod_NAZWAMODA

wpisz:


public int addFuel (int i, int j)
{
if(i== ITEM.IT)
return MOC;
return 0;
}

ITEM - zastąp paliwem

IT- Tu wpisz jeśli dodajesz Blok to wpisz .blockID a jeśli Item wstawiasz to .iconIndex

MOC - zastąp mocą paliwa zacznij od 10 i w góre (polecam wpisać 500000)

11.Inne rozmiary Bloków

Witam, w Następnej Części Poradnika Dziś Zmienimy Rozmiar Bloku

będzie nam potrzeby blok(Zobacz cz.3)

Ok teraz do pliku BlockNAZWABLOKU.java usuwamy zawartość i wklejamy takie coś:

package net.minecraft.src;

public class BlockNAZWABLOKU extends Block
{

public BlockNAZWABLOKU(int blockID)
{
super(blockID, 74, Material.MATERIAł);
setBlockBounds(Wymiary);

}

public boolean renderAsNormalBlock()
{
return false;
}

}

NAZWABLOKU - zastąp swoją nazwą Bloku

MATERIAŁ - zastąp materiałem bloku wood- drewno wool - wełna rock - kamień(resztę w cz.3)

WYMIARY - tu wpisz sowje wymiary Bloku (Pópłytka ma (0F, 0F, 0F, 1F, 0.5F, 1F)

Objaśnienie:

public BlockNAZWABLOKU

Jest to nasz konstruktor bloku

public boolean renderAsNormalBlock()

To Pozwala nam wejść na blok bez pomocy skakania

To już wszystko na tą Lekcje Teraz możecie się cieszyć Blokiem

12.Roślina(a)

Witam dziś stworzymy rośline ale taką podobną do trzciny co znaczy te (a) to Znaczy że będzie jeszcze jedna część o zrobiniu rośliny ale sadzi się nasiąka

To zaczynamy

Pierw Wklejamy konstruktor do naszego mod_NAZWAMODA

public static Block NAZWA = new BlockNAZWAPLIKUBLOKU(ID,
0).setHardness(TWARDOŚĆ).setBlockName("NAZWA");

w funkcij public void load() Wklejamy:

ModLoader.addName(NAZWA, "NAZWAWGRZE");

Teraz tworzymy nasz kod z teksturką:

NAZWA.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "ŚCIEŻKA.png");

I tworzymy takie coś:

ModLoader.registerBlock(NAZWA);

NAZWA - zastąp nazwą rośliny

ŚCIEZKA - zastąp ścieżką do tekstury roślinki

NAZWAPLIKUBLOKU - zastąp nazwą nazwy pliku bloku którego zaraz stworzysz

TWARDOŚĆ - zastąp twardością blok(np: 1.5F) na końcu musi być DUŻE F

NAZWAWGRZE - zastąp nazwą w grze

ID - zastąp id (podałem w cz.3)

ok stwórz plik o nazwie BlockNAZWAPLIKUBLOKU.java:


package net.minecraft.src;

import java.util.Random;

public class BlockNAZWAPLIKUBLOKU extends Block
{
protected BlockNAZWAPLIKUBLOKU(int par1, int par2)
{
super(par1, Material.plants);
func_71849_a(CreativeTabs.field_78030_;
blockIndexInTexture = par2;
float f = 0.375F;
setBlockBounds(0.5F - f, 0.0F, 0.5F - f, 0.5F + f, 1.0F, 0.5F + f);
setTickRandomly(true);
}

/**
* Ticks the block if it's been scheduled
*/
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
if (par1World.isAirBlock(par2, par3 + 1, par4))
{
int i;

for (i = 1; par1World.getBlockId(par2, par3 - i, par4) == blockID; i++) { }

if (i < 3)
{
int j = par1World.getBlockMetadata(par2, par3, par4);

if (j == 15)
{
par1World.setBlockWithNotify(par2, par3 + 1, par4, blockID);
par1World.setBlockMetadataWithNotify(par2, par3, par4, 0);
}
else
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, j + 1);
}
}
}
}

/**
* Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
*/
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
int i = par1World.getBlockId(par2, par3 - 1, par4);

if (i == blockID)
{
return true;
}

if (i != Block.grass.blockID | i != Block.dirt.blockID | i != Block.sand.blockID)
{
return false;
}

if (par1World.getBlockMaterial(par2 - 1, par3 - 1, par4) == Material.MATERIAŁ)
{
return true;
}

if (par1World.getBlockMaterial(par2 + 1, par3 - 1, par4) == Material.MATERIAŁ)
{
return true;
}

if (par1World.getBlockMaterial(par2, par3 - 1, par4 - 1) == Material.MATERIAŁ)
{
return true;
}

return par1World.getBlockMaterial(par2, par3 - 1, par4 + 1) == Material.MATERIAŁ;
}

/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
* their own) Args: x, y, z, neighbor blockID
*/
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
{
checkBlockCoordValid(par1World, par2, par3, par4);
}

/**
* Checks if current block pos is valid, if not, breaks the block as dropable item. Used for reed and cactus.
*/
protected final void checkBlockCoordValid(World par1World, int par2, int par3, int par4)
{
if (!canBlockStay(par1World, par2, par3, par4))
{
dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
}
}

/**
* Can this block stay at this position. Similar to canPlaceBlockAt except gets checked often with plants.
*/
public boolean canBlockStay(World par1World, int par2, int par3, int par4)
{
return canPlaceBlockAt(par1World, par2, par3, par4);
}

/**
* Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
* cleared to be reused)
*/
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int i)
{
return null;
}

/**
* Returns the ID of the items to drop on destruction.
*/
public int idDropped(int par1, Random par2Random, int par3)
{
return ITEM/BLOK.iconIndex;
}

/**
* Is this block (a) opaque and ( 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;
}

/**
* The type of render function that is called for this block
*/
public int getRenderType()
{
return 1;
}
public int func_71922_a(World par1World, int par2, int par3, int par4)
{
return mod_NAZWAMODA.NAZWA.blockID;
}
}

MATERIAŁ - zastąp materiałem koło którego będzie rosła nasz roślina

ITEM/BLOK - zastąp itemem lub blokiem który wypada z rośliny

NAZWAMODA - zastap nazwą pliku głównego(mod_)

NAZWA - podane wyżej

13.Efekty Bloków

Witam dziś pokaże jak dodać do Bloku różne efekty (Żeby się dowidzieć jak go stworzyć przeczytaj cz.3)

W spoilerach masz różne efekty które trzeba Dokleić do konstruktora Bloku(public static Item...)

1.Wytrzymałość Bloku na Uderzenia

Ok To wytrzymałość Bloku na uderzenie

.setHardness(MOC)

2.Wytrzymałość na wybuch

Jeśli to ustawisz to blok będzie miał większą/mniejszą szanse na rozwalenie przy wybuchu

.setResistance(MOC)

3.Jump Blok

Ok to efekt jak wejdziemy na blok to podskakujemy

TO WKLEJAMY DO BlockNAZWABLOKU

public void onEntityWalking(World world, int x, int y, int z, Entity entity)
{
// Add to the entities upward velocity to send them up into the air
entity.motionY += SIŁA;
}

4.Świecenie Bloku

To efekt świecenia bloku w ciemności, wklejamy to do konstruktora bloku[public static final Block...]

.setLightValue(MOC)

5.Dźwięk chodzenia

Ten efekt będzie dodawał dźwięk chodzenia po bloku

.setStepSound(Block.DŹWIEK)

Listę dźwięków masz niżej

MOC - Jest to odporność bloku.Na końcu wpisz DUŻE F

SIŁA - Tu wpisz siłe efektu.Na końcu wpisz DUŻE F

DŹWIEK - Zastąp nazwą dźwięku:

-soundStoneFootstep

-soundGrassFootstep

-soundWoodFootstep

-soundMetalFootstep

-soundGlassFootstep

-soundClothFootstep

-soundSandFootstep

-soundGravelFootstep

np: soundStoneFootstep jest to dźwięk taki jak wejdziemy na stone

14.Modyfikowanie Świata

Witam w tej lekcji będziemy modyfikować nasz świat

1.Zmieniamy Grawitacje

W tej lekcji pokaże jak zmienić grawitacje w świecie

Szukamy plik Entity.java i wyszukujemy public void onUpdate()

i zamień to na to:

public void onUpdate()
{
this.onEntityUpdate();
this.motionY+=GRAWITACJAF;
}

GRAWITACJA - zastąp to grawitacją(ja polecam wartość 0.06F wtedy skaczemy jak w kosmosie)

15.Biomy

Witam w tej lekcji pokaże jak zrobić własnego bioma do minecrafta. Ok zaczynamy

pierw stwórz nowy plik o nazwie BiomeGenNAZWABIOMU

package net.minecraft.src;

public class BiomeGenNAZWABIOMU extends BiomeGenBase
{
public BiomeGenNAZWABIOMU(int par1)
{
super(par1);
this.topBlock = (byte) GóRA.blockID;
this.fillerBlock = (byte) PODGóRĄ3BLOKI.blockID;
}
}

NAZWABIOMU - zastąp to nazwą biomu

GóRA - jest to górny blok inne biomy mają Blok z Trawą

PODGóRĄ3BLOKI - tu zastąp blokami który jest pod górnym blokiem biomu

Możesz Usunąć moby z biomu :

spawnableCreatureList.clear(); - Usuwa zwierzęta na biomie

spawnableWaterCreatureList.clear(); - Usuwa wodne zwierzęta

spawnableMonsterList.clear(); - to usuwa moby(np: Zombie Szkielet itp)

Ok teraz w funkcij public void load() w pliku mod_NAZWAMODA wpisz:

ModLoader.addBiome(NAZWABIOMU)

NAZWABIOMU - pokazałem wyżej(przy pliku BiomeGenNAZWABIOMU)

Otwieramy plik BiomeGenBase i szukamy linijkę Ostatniego Biomu(Biom dżunglowy)

a ta linijka wygląda tak:

public static final BiomeGenBase jungleHills = (new BiomeGenJungle(22)).setColor(2900485).setBiomeName("JungleHills").func_76733_a(5470985).setTemperatureRainfall(1.2F, 0.9F).setMinMaxHeight(1.8F, 0.5F);

i zaraz po tej linijce wklejamy nasz biom:

public static final BiomeGenBase NAZWABIOMU = (new NAZWABIOMU(ID)).setBiomeName("NAZWABIOMU").setTemperatureRainfall(ZIMNO, ZIMNO1).setColor(COLOR);

ID - zastąp to id biomu jak dżunglowy ma 22 to zaczynaj od 23 i w góre

ZIMNO1/ZIMNO - to zastąp temperaturą biomu (polecam to .setTemperatureRainfall(0.0F, 0.5F woda tu będzie zamarzać)

COLOR - zastąp to kolorem zobacz na inne biomy

GRATULACJE STWORZYŁEŚ WŁASNY BIOM!!!

ok jak zawsze podam gotowe pliki ale tym razem do pobrania

https://hotfile.com/..._Gold.java.html - mod_Gold

https://hotfile.com/...nGold.java.html - BiomeGenGold

https://hotfile.com/...nBase.java.html - BiomeGenBase

16.Własny rodzaj narzędzia

Witam, w tej lekcji pokaże jak zrobić własny rodzaj narzędzia:

Pierw szukamy w pliku ItemTYPPickaxe,ItemTYPSword... linijki :

blocksEffectiveAgainst = (new Block[]
{

i tam wklejamy wszystko z ItemTYPPickaxe... z linijki blockEffectiveAgainst...

Przykład:

blocksEffectiveAgainst = (new Block[]
{
Block.cobblestone, Block.stone, Block.sandStone, Block.cobblestoneMossy, Block.oreIron, Block.blockSteel, Block.oreCoal, Block.blockGold,
Block.oreGold, mod_10Mod.BlockAluminium, Block.oreDiamond, Block.blockDiamond, Block.ice, Block.netherrack, Block.oreLapis, Block.blockLapis, Block.oreRedstone, Block.oreRedstoneGlowing, Block.rail,
Block.railDetector, Block.railPowered
Block.planks, Block.bookShelf, Block.wood, Block.chest, Block.pumpkin, Block.pumpkinLantern
Block.grass, Block.dirt, Block.sand, Block.gravel, Block.snow, Block.blockSnow, Block.blockClay, Block.tilledField, Block.slowSand, Block.mycelium
});

To już na koniec z tą lekcją. Pozdrawiam "ElDorado"

17.Własny kwiatek, generowanie go

Witam, w tej lekcji pokaże jak zrobić kwiata i go wygenerować w świecie. Pierw tworzymy nasz konstruktor w pliku mod_NAZWAMODA:

public static final BlockFlower NAZWA = (BlockFlower)(new BlockFlower(ID, 0)).setHardness(WYTRZYMAŁOŚĆF).setBlockName("NAZWA");

NAZWA - zastąp nazwą kwiata

ID - zastąp id bloku

WYTRZYMAŁOŚĆ - zastąp wytrzymałością kwiatka(kwiaty mają 0.0F)

ok teraz w funkcji load() wklej:

ModLoader.addName(NAZWA, "NAZWAWGRZE");
ModLoader.registerBlock(NAZWA);
NAZWA.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "TEKSTURA.png");

NAZWAWGRZE - zastąp nazwą w grze

NAZWA - podałem wcześniej

TEKSTURA - zastąp to ścieżką do tekstury kwiatu

teraz będziemy się zajmować generowaniem kwiatu:

w funkcji public void generateSurface wpisz:


int var5;
int var6;
int var7;
int var8;
for(var5 = 0; var5 < 2; ++var5)
{
var6 = b + random.nextInt(16) + 8;
var7 = random.nextInt(128);
var8 = j + random.nextInt(16) + 8;
(new WorldGenFlowers(mod_10Mod.newflower.blockID)).generate(var1, random, var6, var7, var8);
}

a cały public wygląda tak:


public void generateSurface(World var1, Random random, int b, int j)
{
int var5;
int var6;
int var7;
int var8;
for(var5 = 0; var5 < CZEN; ++var5)
{
var6 = b + random.nextInt(16) + 8;
var7 = random.nextInt(128);
var8 = j + random.nextInt(16) + 8;
(new WorldGenFlowers(mod_10Mod.newflower.blockID)).generate(var1, random, var6, var7, var8);
}

}

CZEN - zastąp jak często będzie się generować kwiat

Na koniec przykłady:

mod_KWIAT


package net.minecraft.src;

import java.util.Random;

public class mod_10Mod extends BaseMod {

public static final BlockFlower Kwiat = (BlockFlower)(new BlockFlower(174, 0)).setHardness(0.0F).setBlockName("Kwiatek");


public String getVersion()
{
return "1.3.1";
}

@Override
public void load () {
}


public mod_KWIAT()
{
ModLoader.registerBlock(Kwiat);
ModLoader.addName(Kwiat, "Tulipan");
Kwiat.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/Tutorial/tulipan.png");
}


public void generateSurface(World var1, Random random, int b, int j)
{
int var5;
int var6;
int var7;
int var8;
for(var5 = 0; var5 < 2; ++var5)
{
var6 = b + random.nextInt(16) + 8;
var7 = random.nextInt(128);
var8 = j + random.nextInt(16) + 8;
(new WorldGenFlowers(mod_KWIAT.Kwiat.blockID)).generate(var1, random, var6, var7, var8);
}

}

To już koniec w następnym poradniku będzie coś specialnego.

18.Zmieniamy zawartość skrzynek w lochach

Witam w kolejnej lekcji dziś pokaże jak zmienić czyli dodać usunąć item do skrzynki w lochach

to zaczynamy.

Otwórz plik WorldGenDungeons.java

i wyszukaj private ItemStack pickCheckLootItem.

Znajdź wyraz "null" usuń te null w wpisz "null)". Ok to teraz przed null zrób spacje i wpisz:

(var2 == POZYCJA ? new ItemStack(Item.ITEM, 1, ILOŚĆ) :

POZYCJA - Zastąp to pozycją.Ostatnia to była 10 czyli wpisz tam 11

ITEM - Zastąp itemem który będzie się generował w skrzyni

ILOŚĆ - Tu wpisz ile maksymalnie może być Itemów w staku(polecam wpisać 3)

19.Blok z inną teksturą na każdej ścianie

Witam dziś pokaże jak zrobić że, każda ściana w bloku na inną teksturę

ok pierw trzeba zrobić ten blok(zobacz w cz.3)

do pliku mod_NAZWAMODA wklejamy to:

public static int NAZWABottom = ModLoader.addOverride("/terrain.png", "ŚCIEŻKADóŁ");
public static int NAZWATop = ModLoader.addOverride("/terrain.png", "ŚCIEŻKAGóRA");
public static int NAZWASides = ModLoader.addOverride("/terrain.png", "ŚCIEŻKABOKI");

ŚCIEŻKADóŁ - Tu wpisz ścieżkę do tekstury spodu bloku,

ŚCIEŻKAGóRA - Tu wpisz ścieżkę do tekstury góry bloku,

ŚCIEŻKABOKI - Tu wpisz ścieżkę do tekstury 2 boków bloku,

NAZWA - zastąp to nazwą bloku.

Teraz w pliku NAZWABLOKU.java dopisz to:

public int getBlockTextureTutekAndMetadata(int i, int j)
{
return getBlockTextureTutek(i);
}
public int getBlockTextureFroTutek(int i)
{
if (i == 0)
{
return mod_NAZWAMODA.NAZWABottom;
}
if (i == 1)
{
return mod_NAZWAMODA.NAZWATop;
}
else
{
return mod_NAZWAMODA.NAZWASides;
}
}

NAZWA - podałem wyżej

20.Własne osiągnięcie(Achievements)

Witam, w tej lekcji pokaże jak dodać własne osiągnięcie(Achievements) które po craftingu jakiegoś bloku lub itemu pokaże się nam, to zaczynamy

Pierw trzba stworzyć kostruktor naszego osiągnięcia:

public static final Achievement NAZWAO = new Achievement(ID, "NAZWAO", 5, 7, Item.iron, null).registerAchievement()

ID - zastąp to id(wpisz 4560)

NAZWAO - zastąp nazwą osiągnięcia

ok teraz w public void load(){ wpisz

ModLoader.addAchievementDesc(NAZWAO, "NAZWAO", "NAZWAWGRZE");

to odpowiada za dodanie do gry osiągnięcia

NAZWAO - podałem wyżej

NAZWAWGRZE - zastąp to nazwą w grze

ok teraz musimy dodać public:

public void takenFromCrafting(EntityPlayer entityplayer, ItemStack itemstack, IInventory iinventory)
{
if(itemstack.itemID == BLOK/ITEM.B/I)
{
entityplayer.addStat(NAZWAO, 1);
}
}

BLOK/ITEM - tu wpisz nazwe itemu/bloku który po craftigu wyskoczy osiągnięcie

B/I - tu jeśli wybrałeś blok to wpisz .blockID a jeśli item to .iconIndex

Właśnie zrobiłeś własne osiągnięcie a ja 20 lekcje.

21.Zbroja

Witam, dziś pokaże jak zrobić własną zbroje

pierw do mod_NAZWAMODA wpisz konstruktory:

public static final Item NAZWA = (new ItemArmor(ID, EnumArmorMaterial.NAZWAZ,ModLoader.addArmor("NAZWATEK"), 0)).setItemName("NAZWA");
public static final Item NAZWA = (new ItemArmor(ID, EnumArmorMaterial.NAZWAZ,ModLoader.addArmor("NAZWATEK"), 1)).setItemName("NAZWA");
public static final Item NAZWA = (new ItemArmor(ID, EnumArmorMaterial.NAZWAZ,ModLoader.addArmor("NAZWATEK"), 2)).setItemName("NAZWA");
public static final Item NAZWA = (new ItemArmor(ID, EnumArmorMaterial.NAZWAZ, ModLoader.addArmor("NAZWATEK"), 3)).setItemName("NAZWA");

NAZWA - zastąp to nazwą zbroi

ID - zastąp to id, zacznij od 1201

NAZWAZ - zastąp to nazwą w pliku którą zaraz stworzysz

NAZWATEK - zastąp to TEKSTURĄ(nie itemem) wejdź w plik armor w minecraft.jar i skopiuj na pulpit diamond_1 i diamond_2 i edytuj to do własnych potrzeb i wpisz w NAZWATEK nazwę tej tekstur ale bez _1

ok teraz w funkcji public void load() wpisz:

ModLoader.addName(NAZWA, "NAZWAWGRZE");
NAZWA.iconIndex = ModLoader.addOverride("/gui/items.png", "/ŚCIEŻKA");

NAZWA - podałem wcześniej

NAZWAWGRZE - chyba nie muszę tłumaczyć

ŚCIEŻKA - zastąp to ścieżką do itemu zbroi NIE TEKSTURY

i jeszcze crafting dodam w następnej lekcji

Otwórz plik EnumArmorMaterial.java i znajdź linijkę:

DIAMOND(33, new int[]{3, 8, 6, 3}, 10);

ta linijka jest na początku

Zamień ";" na "," oczywiście bez "" jest na końcu linijki pod tym wpisz:

NAZWAZ(33, new int[]{3, 8, 6, 3}, 10);

NAZWAZ - podałem wcześniej

te liczby 3, 8, 6, 3}, 10) podam później bo nie wiem co oznacza parametr na końcu

OK teraz podam przykłady:

mod_ArmorEmerald.java :

package net.minecraft.src;

public class mod_beznazwy extends BaseMod {

public static final Item ehelmet = (new ItemArmor(1201, EnumArmorMaterial.EMERALD,ModLoader.addArmor("emerald"), 0)).setItemName("emerald helmet");
public static final Item echestplate = (new ItemArmor(1202, EnumArmorMaterial.EMERALD,ModLoader.addArmor("emerald"), 1)).setItemName("emerald chestplate");
public static final Item epants = (new ItemArmor(1203, EnumArmorMaterial.EMERALD,ModLoader.addArmor("emerald"), 2)).setItemName("emerald pants");
public static final Item eboots = (new ItemArmor(1204, EnumArmorMaterial.EMERALD, ModLoader.addArmor("emerald"), 3)).setItemName("emerald boots");

@Override
public String getVersion() {
// TODO Auto-generated method stub
return "V1.0 MC-1.3.2";
}

@Override
public void load() {
// TODO Auto-generated method stub

}

public mod_beznazwy(){
ModLoader.addName(ehelmet, "Emerald Helmet");
ModLoader.addName(echestplate, "Emerald Chestplate");
ModLoader.addName(epants, "Emerald Boots");
ModLoader.addName(eboots, "Emerald Leggigns");

ehelmet.iconIndex = ModLoader.addOverride("/gui/items.png", "/EmeraldH.png");
echestplate.iconIndex = ModLoader.addOverride("/gui/items.png", "/EmeraldCH.png");
epants.iconIndex = ModLoader.addOverride("/gui/items.png", "/EmeraldL.png");
eboots.iconIndex = ModLoader.addOverride("/gui/items.png", "/EmeraldB.png");

}
}

EnumArmorMaterial.java :

package net.minecraft.src;

public enum EnumArmorMaterial
{
CLOTH(5, new int[]{1, 3, 2, 1}, 15),
CHAIN(15, new int[]{2, 5, 4, 1}, 12),
IRON(15, new int[]{2, 6, 5, 2}, 9),
GOLD(7, new int[]{2, 5, 3, 1}, 25),
DIAMOND(33, new int[]{3, 8, 6, 3}, 10),
EMERALD(40, new int[]{5, 10, 7, 5}, 50);

/**
* Holds the maximum damage factor (each piece multiply this by it's own value) of the material, this is the item
* damage (how much can absorb before breaks)
*/
private int maxDamageFactor;

/**
* Holds the damage reduction (each 1 points is half a shield on gui) of each piece of armor (helmet, plate, legs
* and boots)
*/
private int[] damageReductionAmountArray;

/** Return the enchantability factor of the material */
private int enchantability;

private EnumArmorMaterial(int par3, int[] par4ArrayOfInteger, int par5)
{
this.maxDamageFactor = par3;
this.damageReductionAmountArray = par4ArrayOfInteger;
this.enchantability = par5;
}

/**
* Returns the durability for a armor slot of for this type.
*/
public int getDurability(int par1)
{
return ItemArmor.getMaxDamageArray()[par1] * this.maxDamageFactor;
}

/**
* Return the damage reduction (each 1 point is a half a shield on gui) of the piece index passed (0 = helmet, 1 =
* plate, 2 = legs and 3 = boots)
*/
public int getDamageReductionAmount(int par1)
{
return this.damageReductionAmountArray[par1];
}

/**
* Return the enchantability factor of the material.
*/
public int getEnchantability()
{
return this.enchantability;
}
}

22.Własny Przycisk

Witam, w tej części pokaże jak zrobić własny przycisk pierw w mod_NAZWAMODA dodaj konstruktor:

public static Block NAZWA = new NAZWAPLIKUBLOKU(ID, TEKSTURA).setResistance(0.5F).setRequiresSelfNotify().setBlockName("NAZWA);

NAZWA - zastąp nazwą przycisku

NAZWAPLIKUBLOKU - tu wpisz nazwe pliku bloku którą, zaraz stworzysz

ID- zastąp to id buttona

TEKSTURA - tu wpisz jakiś blok a przycisk weźmie jego teksture(będzie wyglądał jak podany blok)

teraz w funkcji public void load() wpisz:

ModLoader.addName(NAZWA, "NAZWAWGRZE");
ModLoader.registerBlock(NAZWA);

NAZWA - podałem wcześniej

NAZWAWGRZE - tu wpisz jak będzie się nazywał przycisk w grze

Stwórz teraz plik o nazwie NAZWAPLIKUBLOKU.java:

package net.minecraft.src;

import java.util.Random;

public class BlockAButton extends Block
{
protected NAZWAPLIKUBLOKU(int par1, int par2)
{
super(par1, par2, Material.circuits);
this.setTickRandomly(true);
this.setCreativeTab(CreativeTabs.tabRedstone);
}

/**
* Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
* cleared to be reused)
*/
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
return null;
}

/**
* How many world ticks before ticking
*/
public int tickRate()
{
return 20;
}

/**
* Is this block (a) opaque and ( 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;
}

/**
* checks to see if you can place this block can be placed on that side of a block: BlockLever overrides
*/
public boolean canPlaceBlockOnSide(World par1World, int par2, int par3, int par4, int par5)
{
return par5 == 2 || par1World.isBlockNormalCube(par2, par3, par4 + 1) ? true : (par5 == 3 || par1World.isBlockNormalCube(par2, par3, par4 - 1) ? true : (par5 == 4 || par1World.isBlockNormalCube(par2 + 1, par3, par4) ? true : par5 == 5 || par1World.isBlockNormalCube(par2 - 1, par3, par4)));
}

/**
* Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
*/
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
return par1World.isBlockNormalCube(par2 - 1, par3, par4) ? true : (par1World.isBlockNormalCube(par2 + 1, par3, par4) ? true : (par1World.isBlockNormalCube(par2, par3, par4 - 1) ? true : par1World.isBlockNormalCube(par2, par3, par4 + 1)));
}

/**
* called before onBlockPlacedBy by ItemBlock and ItemReed
*/
public void updateBlockMetadata(World par1World, int par2, int par3, int par4, int par5, float par6, float par7, float par8)
{
int var9 = par1World.getBlockMetadata(par2, par3, par4);
int var10 = var9 | 8;
var9 |= 7;

if (par5 == 2 || par1World.isBlockNormalCube(par2, par3, par4 + 1))
{
var9 = 4;
}
else if (par5 == 3 || par1World.isBlockNormalCube(par2, par3, par4 - 1))
{
var9 = 3;
}
else if (par5 == 4 || par1World.isBlockNormalCube(par2 + 1, par3, par4))
{
var9 = 2;
}
else if (par5 == 5 || par1World.isBlockNormalCube(par2 - 1, par3, par4))
{
var9 = 1;
}
else
{
var9 = this.getOrientation(par1World, par2, par3, par4);
}

par1World.setBlockMetadataWithNotify(par2, par3, par4, var9 + var10);
}

/**
* Get side which this button is facing.
*/
private int getOrientation(World par1World, int par2, int par3, int par4)
{
return par1World.isBlockNormalCube(par2 - 1, par3, par4) ? 1 : (par1World.isBlockNormalCube(par2 + 1, par3, par4) ? 2 : (par1World.isBlockNormalCube(par2, par3, par4 - 1) ? 3 : (par1World.isBlockNormalCube(par2, par3, par4 + 1) ? 4 : 1)));
}

/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
* their own) Args: x, y, z, neighbor blockID
*/
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
{
if (this.redundantCanPlaceBlockAt(par1World, par2, par3, par4))
{
int var6 = par1World.getBlockMetadata(par2, par3, par4) | 7;
boolean var7 = false;

if (!par1World.isBlockNormalCube(par2 - 1, par3, par4) || var6 == 1)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2 + 1, par3, par4) || var6 == 2)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2, par3, par4 - 1) || var6 == 3)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2, par3, par4 + 1) || var6 == 4)
{
var7 = true;
}

if (var7)
{
this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
}
}
}

/**
* This method is redundant, check it out...
*/
private boolean redundantCanPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
if (!this.canPlaceBlockAt(par1World, par2, par3, par4))
{
this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
return false;
}
else
{
return true;
}
}

/**
* Updates the blocks bounds based on its current state. Args: world, x, y, z
*/
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
int var6 = var5 | 7;
boolean var7 = (var5 | 8) > 0;
float var8 = 0.375F;
float var9 = 0.625F;
float var10 = 0.1875F;
float var11 = 0.125F;

if (var7)
{
var11 = 0.0625F;
}

if (var6 == 1)
{
this.setBlockBounds(0.0F, var8, 0.5F - var10, var11, var9, 0.5F + var10);
}
else if (var6 == 2)
{
this.setBlockBounds(1.0F - var11, var8, 0.5F - var10, 1.0F, var9, 0.5F + var10);
}
else if (var6 == 3)
{
this.setBlockBounds(0.5F - var10, var8, 0.0F, 0.5F + var10, var9, var11);
}
else if (var6 == 4)
{
this.setBlockBounds(0.5F - var10, var8, 1.0F - var11, 0.5F + var10, var9, 1.0F);
}
}

/**
* Called when the block is clicked by a player. Args: x, y, z, entityPlayer
*/
public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
{
this.onBlockActivated(par1World, par2, par3, par4, par5EntityPlayer, 0, 0.0F, 0.0F, 0.0F);
}

/**
* Called upon block activation (right click on the block.)
*/
public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
{
int var10 = par1World.getBlockMetadata(par2, par3, par4);
int var11 = var10 | 7;
int var12 = 8 - (var10 | 8);

if (var12 == 0)
{
return true;
}
else
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, var11 + var12);
par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
par1World.playSoundEffect((double)par2 + 0.5D, (double)par3 + 0.5D, (double)par4 + 0.5D, "random.click", 0.3F, 0.6F);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);

if (var11 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var11 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var11 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var11 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}

par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
return true;
}
}

/**
* ejects contained items into the world, and notifies neighbours of an update, as appropriate
*/
public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
{
if ((par6 | 8) > 0)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
int var7 = par6 | 7;

if (var7 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var7 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var7 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var7 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}
}

super.breakBlock(par1World, par2, par3, par4, par5, par6);
}

/**
* Is this block powering the block on the specified side
*/
public boolean isPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
return (par1IBlockAccess.getBlockMetadata(par2, par3, par4) | 8) > 0;
}

/**
* Is this block indirectly powering the block on the specified side
*/
public boolean isIndirectlyPoweringTo(World par1World, int par2, int par3, int par4, int par5)
{
int var6 = par1World.getBlockMetadata(par2, par3, par4);

if ((var6 | 8) == 0)
{
return false;
}
else
{
int var7 = var6 | 7;
return var7 == 5 || par5 == 1 ? true : (var7 == 4 || par5 == 2 ? true : (var7 == 3 || par5 == 3 ? true : (var7 == 2 || par5 == 4 ? true : var7 == 1 || par5 == 5)));
}
}

/**
* Can this block provide power. Only wire currently seems to have this change based on its state.
*/
public boolean canProvidePower()
{
return true;
}

/**
* Ticks the block if it's been scheduled
*/
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
if (!par1World.isRemote)
{
int var6 = par1World.getBlockMetadata(par2, par3, par4);

if ((var6 | 8) != 0)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, var6 | 7);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
int var7 = var6 | 7;

if (var7 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var7 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var7 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var7 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}

par1World.playSoundEffect((double)par2 + 0.5D, (double)par3 + 0.5D, (double)par4 + 0.5D, "random.click", 0.3F, 0.5F);
par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
}
}
}

/**
* Sets the block's bounds for rendering it as an item
*/
public void setBlockBoundsForItemRender()
{
float var1 = 0.1875F;
float var2 = 0.125F;
float var3 = 0.125F;
this.setBlockBounds(0.5F - var1, 0.5F - var2, 0.5F - var3, 0.5F + var1, 0.5F + var2, 0.5F + var3);
}
}

NAZWAPLIKUBLOKU - podałem wcześniej

ok stworzyłeś przycisk teraz podam przykłady:

mod_GlowButton:

package net.minecraft.src;

public class mod_GlowButton extends BaseMod {

public static Block button = new BlockGlow(159, Block.glowStone.blockIndexInTexture).setResistance(0.5F).setLightValue(1.0F).setRequiresSelfNotify().setBlockName("Glow button");


@Override
public String getVersion() {
// TODO Auto-generated method stub
return "V1.0 MC-1.3.2";
}

@Override
public void load() {
// TODO Auto-generated method stub

}

public mod_GlowButton(){
ModLoader.addName(button, "Glowstone Button");
ModLoader.registerBlock(button);

}
}

BlockGlow.java :

package net.minecraft.src;

import java.util.Random;

public class BlockGlow extends Block
{
protected BlockGlow(int par1, int par2)
{
super(par1, par2, Material.circuits);
this.setTickRandomly(true);
this.setCreativeTab(CreativeTabs.tabRedstone);
}

/**
* Returns a bounding box from the pool of bounding boxes (this means this box can change after the pool has been
* cleared to be reused)
*/
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4)
{
return null;
}

/**
* How many world ticks before ticking
*/
public int tickRate()
{
return 20;
}

/**
* Is this block (a) opaque and ( 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;
}

/**
* checks to see if you can place this block can be placed on that side of a block: BlockLever overrides
*/
public boolean canPlaceBlockOnSide(World par1World, int par2, int par3, int par4, int par5)
{
return par5 == 2 || par1World.isBlockNormalCube(par2, par3, par4 + 1) ? true : (par5 == 3 || par1World.isBlockNormalCube(par2, par3, par4 - 1) ? true : (par5 == 4 || par1World.isBlockNormalCube(par2 + 1, par3, par4) ? true : par5 == 5 || par1World.isBlockNormalCube(par2 - 1, par3, par4)));
}

/**
* Checks to see if its valid to put this block at the specified coordinates. Args: world, x, y, z
*/
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
return par1World.isBlockNormalCube(par2 - 1, par3, par4) ? true : (par1World.isBlockNormalCube(par2 + 1, par3, par4) ? true : (par1World.isBlockNormalCube(par2, par3, par4 - 1) ? true : par1World.isBlockNormalCube(par2, par3, par4 + 1)));
}

/**
* called before onBlockPlacedBy by ItemBlock and ItemReed
*/
public void updateBlockMetadata(World par1World, int par2, int par3, int par4, int par5, float par6, float par7, float par8)
{
int var9 = par1World.getBlockMetadata(par2, par3, par4);
int var10 = var9 | 8;
var9 |= 7;

if (par5 == 2 || par1World.isBlockNormalCube(par2, par3, par4 + 1))
{
var9 = 4;
}
else if (par5 == 3 || par1World.isBlockNormalCube(par2, par3, par4 - 1))
{
var9 = 3;
}
else if (par5 == 4 || par1World.isBlockNormalCube(par2 + 1, par3, par4))
{
var9 = 2;
}
else if (par5 == 5 || par1World.isBlockNormalCube(par2 - 1, par3, par4))
{
var9 = 1;
}
else
{
var9 = this.getOrientation(par1World, par2, par3, par4);
}

par1World.setBlockMetadataWithNotify(par2, par3, par4, var9 + var10);
}

/**
* Get side which this button is facing.
*/
private int getOrientation(World par1World, int par2, int par3, int par4)
{
return par1World.isBlockNormalCube(par2 - 1, par3, par4) ? 1 : (par1World.isBlockNormalCube(par2 + 1, par3, par4) ? 2 : (par1World.isBlockNormalCube(par2, par3, par4 - 1) ? 3 : (par1World.isBlockNormalCube(par2, par3, par4 + 1) ? 4 : 1)));
}

/**
* Lets the block know when one of its neighbor changes. Doesn't know which neighbor changed (coordinates passed are
* their own) Args: x, y, z, neighbor blockID
*/
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, int par5)
{
if (this.redundantCanPlaceBlockAt(par1World, par2, par3, par4))
{
int var6 = par1World.getBlockMetadata(par2, par3, par4) | 7;
boolean var7 = false;

if (!par1World.isBlockNormalCube(par2 - 1, par3, par4) || var6 == 1)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2 + 1, par3, par4) || var6 == 2)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2, par3, par4 - 1) || var6 == 3)
{
var7 = true;
}

if (!par1World.isBlockNormalCube(par2, par3, par4 + 1) || var6 == 4)
{
var7 = true;
}

if (var7)
{
this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
}
}
}

/**
* This method is redundant, check it out...
*/
private boolean redundantCanPlaceBlockAt(World par1World, int par2, int par3, int par4)
{
if (!this.canPlaceBlockAt(par1World, par2, par3, par4))
{
this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
par1World.setBlockWithNotify(par2, par3, par4, 0);
return false;
}
else
{
return true;
}
}

/**
* Updates the blocks bounds based on its current state. Args: world, x, y, z
*/
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
int var5 = par1IBlockAccess.getBlockMetadata(par2, par3, par4);
int var6 = var5 | 7;
boolean var7 = (var5 | 8) > 0;
float var8 = 0.375F;
float var9 = 0.625F;
float var10 = 0.1875F;
float var11 = 0.125F;

if (var7)
{
var11 = 0.0625F;
}

if (var6 == 1)
{
this.setBlockBounds(0.0F, var8, 0.5F - var10, var11, var9, 0.5F + var10);
}
else if (var6 == 2)
{
this.setBlockBounds(1.0F - var11, var8, 0.5F - var10, 1.0F, var9, 0.5F + var10);
}
else if (var6 == 3)
{
this.setBlockBounds(0.5F - var10, var8, 0.0F, 0.5F + var10, var9, var11);
}
else if (var6 == 4)
{
this.setBlockBounds(0.5F - var10, var8, 1.0F - var11, 0.5F + var10, var9, 1.0F);
}
}

/**
* Called when the block is clicked by a player. Args: x, y, z, entityPlayer
*/
public void onBlockClicked(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer)
{
this.onBlockActivated(par1World, par2, par3, par4, par5EntityPlayer, 0, 0.0F, 0.0F, 0.0F);
}

/**
* Called upon block activation (right click on the block.)
*/
public boolean onBlockActivated(World par1World, int par2, int par3, int par4, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9)
{
int var10 = par1World.getBlockMetadata(par2, par3, par4);
int var11 = var10 | 7;
int var12 = 8 - (var10 | 8);

if (var12 == 0)
{
return true;
}
else
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, var11 + var12);
par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
par1World.playSoundEffect((double)par2 + 0.5D, (double)par3 + 0.5D, (double)par4 + 0.5D, "random.click", 0.3F, 0.6F);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);

if (var11 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var11 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var11 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var11 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}

par1World.scheduleBlockUpdate(par2, par3, par4, this.blockID, this.tickRate());
return true;
}
}

/**
* ejects contained items into the world, and notifies neighbours of an update, as appropriate
*/
public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6)
{
if ((par6 | 8) > 0)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
int var7 = par6 | 7;

if (var7 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var7 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var7 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var7 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}
}

super.breakBlock(par1World, par2, par3, par4, par5, par6);
}

/**
* Is this block powering the block on the specified side
*/
public boolean isPoweringTo(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5)
{
return (par1IBlockAccess.getBlockMetadata(par2, par3, par4) | 8) > 0;
}

/**
* Is this block indirectly powering the block on the specified side
*/
public boolean isIndirectlyPoweringTo(World par1World, int par2, int par3, int par4, int par5)
{
int var6 = par1World.getBlockMetadata(par2, par3, par4);

if ((var6 | 8) == 0)
{
return false;
}
else
{
int var7 = var6 | 7;
return var7 == 5 || par5 == 1 ? true : (var7 == 4 || par5 == 2 ? true : (var7 == 3 || par5 == 3 ? true : (var7 == 2 || par5 == 4 ? true : var7 == 1 || par5 == 5)));
}
}

/**
* Can this block provide power. Only wire currently seems to have this change based on its state.
*/
public boolean canProvidePower()
{
return true;
}

/**
* Ticks the block if it's been scheduled
*/
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random)
{
if (!par1World.isRemote)
{
int var6 = par1World.getBlockMetadata(par2, par3, par4);

if ((var6 | 8) != 0)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, var6 | 7);
par1World.notifyBlocksOfNeighborChange(par2, par3, par4, this.blockID);
int var7 = var6 | 7;

if (var7 == 1)
{
par1World.notifyBlocksOfNeighborChange(par2 - 1, par3, par4, this.blockID);
}
else if (var7 == 2)
{
par1World.notifyBlocksOfNeighborChange(par2 + 1, par3, par4, this.blockID);
}
else if (var7 == 3)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 - 1, this.blockID);
}
else if (var7 == 4)
{
par1World.notifyBlocksOfNeighborChange(par2, par3, par4 + 1, this.blockID);
}
else
{
par1World.notifyBlocksOfNeighborChange(par2, par3 - 1, par4, this.blockID);
}

par1World.playSoundEffect((double)par2 + 0.5D, (double)par3 + 0.5D, (double)par4 + 0.5D, "random.click", 0.3F, 0.5F);
par1World.markBlocksDirty(par2, par3, par4, par2, par3, par4);
}
}
}

/**
* Sets the block's bounds for rendering it as an item
*/
public void setBlockBoundsForItemRender()
{
float var1 = 0.1875F;
float var2 = 0.125F;
float var3 = 0.125F;
this.setBlockBounds(0.5F - var1, 0.5F - var2, 0.5F - var3, 0.5F + var1, 0.5F + var2, 0.5F + var3);
}
}

23.Własny napój

Witam dziś pokaże jak zrobić własny napój to zaczynajmy

pierw do mod_NAZWAMODA.java wklej konstruktor:

public static Item NAZWA = (new ItemNAZWAPLIKU(ID)).setItemName("NAZWA");

NAZWA - zastąp to nazwą napoju

NAZWAPLIKU - tu wpisz nazwe pliku napoju

ID - wpisz tu ID napoju(zacznij od 503)

ok stwórz teraz plik ItemNAZWAPLIKU.java:


package net.minecraft.src;

public class ItemNAZWAPLIKU extends Item
{
public ItemNAZWAPLIKU(int var1)
{
super(var1);
this.setMaxStackSize(STAK);
}


/**
* How long it takes to use or consume an item
*/
public int getMaxItemUseDuration(ItemStack var1)
{
return 32;
}

/**
* returns the action that specifies what animation to play when the items is being used
*/
public EnumAction getItemUseAction(ItemStack var1)
{
return EnumAction.drink;
}

/**
* Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
*/
public ItemStack onItemRightClick(ItemStack var1, World var2, EntityPlayer var3)
{
var3.setItemInUse(var1, this.getMaxItemUseDuration(var1));
return var1;
}
}

STAK - tu wpisz po ile będzie się stakował napój

Przykłady:

mod_CocaCola.java:


package net.minecraft.src;

public class mod_CocaCola extends BaseMod
{
public static Item CocaCola = (new ItemCola(503)).setItemName("Coca Cola");

public String getVersion()
{
return "V1.0 MC-1.3.2";
}

public void load() {}

public mod_CocaCola()
{
ModLoader.addName(CocaCola, "Coca Cola");
CocaCola.iconIndex = ModLoader.addOverride("/gui/items.png", "/CocaCola.png");

}
}

ItemCola.java:


package net.minecraft.src;

public class ItemCola extends Item
{
public ItemCola(int var1)
{
super(var1);
this.setMaxStackSize(16);
this.setTabToDisplayOn(CreativeTabs.tabFood);
}



/**
* How long it takes to use or consume an item
*/
public int getMaxItemUseDuration(ItemStack var1)
{
return 32;
}

/**
* returns the action that specifies what animation to play when the items is being used
*/
public EnumAction getItemUseAction(ItemStack var1)
{
return EnumAction.drink;
}

/**
* Called whenever this item is equipped and the right mouse button is pressed. Args: itemStack, world, entityPlayer
*/
public ItemStack onItemRightClick(ItemStack var1, World var2, EntityPlayer var3)
{
var3.setItemInUse(var1, this.getMaxItemUseDuration(var1));
return var1;
}
}

24.Dodanie efektów do jedzenia

Witam, dziś pokaże jak dodać do jedzenia efekty. Pierw zmieniamy konstruktor w pliku mod_NAZWAMODA.java:

public static Item NAZWA = (new ItemNAZWAPLIKU(ID, 0, WILK)).setAlwaysEdible.setItemName("NAZWA");

NAZWA - zastąp to nazwą jedzenia

ID - tu wpisz id jedzenia

NAZWAPLIKU - wpisz nazwę pliku

WILK - tu wpisz czy da się tym oswajać wilki czy nie(true - TAK, false - NIE)

ok stwórz plik o nazwie ItemNAZWAPLIKU.java:


package net.minecraft.src;

public class ItemNAZWAPLIKU extends ItemFood
{
public ItemNAZWAPLIKU(int var1, int var2, boolean var3)
{
super(var1, var2, var3);
}

public ItemStack onFoodEaten(ItemStack var1, World var2, EntityPlayer var3)
{
var3.getFoodStats().addStats(this);
--var1.stackSize;
var3.addPotionEffect(new PotionEffect(Potion.EFEKT.id, CZAS, 1));
return var1;
}
}

EFEKT - tu wpisz efekt który po zjedzeniu pojawi się(usuń tą "." po Potion i wpisz ją jeszcze raz a wyświetlą ci się efekty)

CZAS - tu wpisz czas efektu (5400 u mnie jest to 4min 28sekund)

25.Własny pistolet i naboje

Witam, w tej lekcji pokaże jak zrobić własny pistolet i do tego naboje.Ok możemy zacząć.W kodzie jest błąd nie widać lecącego naboju

mod_NAZWAMODA.java:


package net.minecraft.src;
public class mod_NAZWAMODA extends BaseMod{

public static Item NAZWABRONI = new ItemNAZWAPLIKUBRONI(ID).setItemName("NAZWABRONI");
public static Item NAZWANABOJU = new Item(ID).setItemName("NAZWANABOJU");

@Override
public String getVersion() {
return "WERSJA";
}

@Override
public void load() {
ModLoader.addName(NAZWABRONI , "NAZWAWGRZEBRONI");
ModLoader.addName(NAZWANABOJU, "NAZWAWGRZENABOJU");

NAZWABRONI.iconIndex = ModLoader.addOverride("/gui/items.png", "ŚCIEŻKA.png");
NAZWANABOJU.iconIndex = ModLoader.addOverride("/gui/items.png", "ŚCIEŻKA.png");

}

}

NAZWABRONI - zastąp to nazwą broni

NAZWANABOJU - zastąp to nazwą naboju

NAZWAPLIKUBRONI - Tu wpisz nazwę pliku broni

ID - zastąp to id itemu

WERSJA - zastąp wersją moda

NAZWAWGRZEBRONI - tu wpisz nazwę która będzie widoczna w grze

NAZWAWGRZENABOJU - tu wpisz nazwę która będzie widoczna w grze

ŚCIEŻKA - zastąp to ścieżką do itemów

Stwórz plik o nazwie ItemNAZWAPLIKUBRONI.java:


package net.minecraft.src;

public class ItemNAZWAPLIKUBRONI extends Item
{
public ItemNAZWAPLIKUBRONI(int par1)
{
super(par1);
this.maxStackSize = 1;
this.setTabToDisplayOn(CreativeTabs.CREATIVE);
}


public ItemStack onItemRightClick(ItemStack par1ItemStack, World par2World, EntityPlayer par3EntityPlayer)
{
boolean var5 = par3EntityPlayer.capabilities.disableDamage;

if (!par3EntityPlayer.capabilities.disableDamage)
{
if (var5 || par3EntityPlayer.inventory.hasItem(mod_NAZWAMODA.NAZWANABOJU.shiftedIndex))
{
if (!var5)
{
par3EntityPlayer.inventory.consumeInventoryItem(mod_NAZWAMODA.NAZWANABOJU.shiftedIndex);
if (!par2World.isRemote)
{
par2World.spawnEntityInWorld(new EntityNAZWANABOJU(par2World, par3EntityPlayer));
}

par2World.playSoundAtEntity(par3EntityPlayer, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
}
}
}
return par1ItemStack;
}
}

Wszystko wytłumaczone wyżej

Stwórz plik o nazwie EntityNAZWANABOJU.java:


package net.minecraft.src;

public class EntityNAZWANABOJU extends EntityThrowable
{
public EntityNAZWANABOJU(World par1World)
{
super(par1World);
}

public EntityNAZWANABOJU(World par1World, EntityLiving par2EntityLiving)
{
super(par1World, par2EntityLiving);
}

public EntityNAZWANABOJU(World par1World, double par2, double par4, double par6)
{
super(par1World, par2, par4, par6);
}

protected void onImpact(MovingObjectPosition par1MovingObjectPosition)
{
if (par1MovingObjectPosition.entityHit != null)
{
/**The damage is this variable
* \/ **/
byte var2 = 5;

if (par1MovingObjectPosition.entityHit.attackEntityFrom(DamageSource.causeThrownDamage(this, this.thrower), var2))
{
;
}
}

for (int var3 = 0; var3 < 8; ++var3)
{
this.worldObj.spawnParticle("snowballpoof", this.posX, this.posY, this.posZ, 0.0D, 0.0D, 0.0D);
}

if (!this.worldObj.isRemote)
{
this.setDead();
}
}
}

Prawa autorskie dla wszystkich lekcji a szczególnie dla tej.NIE KOPIOWAĆ DO INNYCH TUTÓW. Lekcja specialnie dla Maganessu na potrzeby jego moda

26.Własny typ świata

Witam, dziś pokaże jak zrobić własny typ świata to zaczynajmy

Pierw do mod_NAZWAMODA w funkcji public void load() wpisz :

ModLoader.addLocalization("generator.NAZWAWGRZE", "NAZWAWGRZE");

NAZWAWGRZE - Tu wpisz nazwę świata

Stwórz plik o nazwie NAZWAWorldType.java:


package net.minecraft.src;

public class NAZWAWorldType extends WorldType {
public NAZWAWorldType() {
super(2, "NAZWAWGRZE");
}


public boolean hasVoidParticles(boolean flag) {
return false;
}

public int getSeaLevel(World world) {
return 64;
}

public double voidFadeMagnitude() {
return 0.0D;
}
}

Stwórz plik o nazwie NAZWAChunkManager.java:


package net.minecraft.src;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class NAZWAChunkManager
{
private GenLayer genBiomes;

/** A GenLayer containing the indices into BiomeGenBase.biomeList[] */
private GenLayer biomeIndexLayer;

/** The BiomeCache object for this world. */
private BiomeCache biomeCache;

/** A list of biomes that the player can spawn in. */
private List biomesToSpawnIn;

protected NAZWAChunkManager()
{
this.biomesToSpawnIn = new ArrayList();
this.biomesToSpawnIn.add(BiomeGenBase.NAZWABIOMU);
}

public NAZWAChunkManager(long par1, WorldType par3WorldType)
{
this();
GenLayer[] var4 = GenLayer.initializeAllBiomeGenerators(par1, par3WorldType);
this.genBiomes = var4[0];
this.biomeIndexLayer = var4[1];
}

public NAZWAChunkManager(World par1World)
{
this(par1World.getSeed(), par1World.getWorldInfo().getTerrainType());
}

/**
* Gets the list of valid biomes for the player to spawn in.
*/
public List getBiomesToSpawnIn()
{
return this.biomesToSpawnIn;
}

/**
* Returns the BiomeGenBase related to the x, z position on the world.
*/
public BiomeGenBase getBiomeGenAt(int par1, int par2)
{
return this.biomeCache.getBiomeGenAt(par1, par2);
}

/**
* Returns a list of rainfall values for the specified blocks. Args: listToReuse, x, z, width, length.
*/
public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();

if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
{
par1ArrayOfFloat = new float[par4 * par5];
}

int[] var6 = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

for (int var7 = 0; var7 < par4 * par5; ++var7)
{
float var8 = (float)BiomeGenBase.biomeList[var6[var7]].getIntRainfall() / 65536.0F;

if (var8 > 1.0F)
{
var8 = 1.0F;
}

par1ArrayOfFloat[var7] = var8;
}

return par1ArrayOfFloat;
}

/**
* Return an adjusted version of a given temperature based on the y height
*/
public float getTemperatureAtHeight(float par1, int par2)
{
return par1;
}

/**
* Returns a list of temperatures to use for the specified blocks. Args: listToReuse, x, y, width, length
*/
public float[] getTemperatures(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();

if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)
{
par1ArrayOfFloat = new float[par4 * par5];
}

int[] var6 = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

for (int var7 = 0; var7 < par4 * par5; ++var7)
{
float var8 = (float)BiomeGenBase.biomeList[var6[var7]].getIntTemperature() / 65536.0F;

if (var8 > 1.0F)
{
var8 = 1.0F;
}

par1ArrayOfFloat[var7] = var8;
}

return par1ArrayOfFloat;
}

/**
* Returns an array of biomes for the location input.
*/
public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)
{
IntCache.resetIntCache();

if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)
{
par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
}

int[] var6 = this.genBiomes.getInts(par2, par3, par4, par5);

for (int var7 = 0; var7 < par4 * par5; ++var7)
{
par1ArrayOfBiomeGenBase[var7] = BiomeGenBase.biomeList[var6[var7]];
}

return par1ArrayOfBiomeGenBase;
}

/**
* Returns biomes to use for the blocks and loads the other data like temperature and humidity onto the
* WorldChunkManager Args: oldBiomeList, x, z, width, depth
*/
public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)
{
return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true);
}

/**
* Return a list of biomes for the specified blocks. Args: listToReuse, x, y, width, length, cacheFlag (if false,
* don't check biomeCache to avoid infinite loop in BiomeCacheBlock)
*/
public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5, boolean par6)
{
IntCache.resetIntCache();

if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)
{
par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
}

if (par6 && par4 == 16 && par5 == 16 && (par2 & 15) == 0 && (par3 & 15) == 0)
{
BiomeGenBase[] var9 = this.biomeCache.getCachedBiomes(par2, par3);
System.arraycopy(var9, 0, par1ArrayOfBiomeGenBase, 0, par4 * par5);
return par1ArrayOfBiomeGenBase;
}
else
{
int[] var7 = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

for (int var8 = 0; var8 < par4 * par5; ++var8)
{
par1ArrayOfBiomeGenBase[var8] = BiomeGenBase.biomeList[var7[var8]];
}

return par1ArrayOfBiomeGenBase;
}
}

/**
* checks given Chunk's Biomes against List of allowed ones
*/
public boolean areBiomesViable(int par1, int par2, int par3, List par4List)
{
int var5 = par1 - par3 >> 2;
int var6 = par2 - par3 >> 2;
int var7 = par1 + par3 >> 2;
int var8 = par2 + par3 >> 2;
int var9 = var7 - var5 + 1;
int var10 = var8 - var6 + 1;
int[] var11 = this.genBiomes.getInts(var5, var6, var9, var10);

for (int var12 = 0; var12 < var9 * var10; ++var12)
{
BiomeGenBase var13 = BiomeGenBase.biomeList[var11[var12]];

if (!par4List.contains(var13))
{
return false;
}
}

return true;
}

/**
* Finds a valid position within a range, that is in one of the listed biomes. Searches {par1,par2} +-par3 blocks.
* Strongly favors positive y positions.
*/
public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random)
{
int var6 = par1 - par3 >> 2;
int var7 = par2 - par3 >> 2;
int var8 = par1 + par3 >> 2;
int var9 = par2 + par3 >> 2;
int var10 = var8 - var6 + 1;
int var11 = var9 - var7 + 1;
int[] var12 = this.genBiomes.getInts(var6, var7, var10, var11);
ChunkPosition var13 = null;
int var14 = 0;

for (int var15 = 0; var15 < var12.length; ++var15)
{
int var16 = var6 + var15 % var10 << 2;
int var17 = var7 + var15 / var10 << 2;
BiomeGenBase var18 = BiomeGenBase.biomeList[var12[var15]];

if (par4List.contains(var18) && (var13 == null || par5Random.nextInt(var14 + 1) == 0))
{
var13 = new ChunkPosition(var16, 0, var17);
++var14;
}
}

return var13;
}

/**
* Calls the WorldChunkManager's biomeCache.cleanupCache()
*/
public void cleanupCache()
{
this.biomeCache.cleanupCache();
}
}

NAZWABIOMU - Tu wpisz nazwę biomu który ma się generować w tym świecie

I Stwórz ostatni plik o nazwie NAZWAChunkProvider.java:


package net.minecraft.src;

public abstract class NAZWAChunkProvider
{
/** world object being used */
public World worldObj;
public WorldType terrainType;

/** World chunk manager being used to generate chunks */
public WorldChunkManager worldChunkMgr;

/**
* States whether the Hell world provider is used(true) or if the normal world provider is used(false)
*/
public boolean isHellWorld = false;

/**
* A boolean that tells if a world does not have a sky. Used in calculating weather and skylight
*/
public boolean hasNoSky = false;

/** Light to brightness conversion table */
public float[] lightBrightnessTable = new float[16];

/** 0 for normal world -1 for hell */
public int worldType = 0;

/** Array for sunrise/sunset colors (RGBA) */
private float[] colorsSunriseSunset = new float[4];

/**
* associate an existing world with a World provider, and setup its lightbrightness table
*/
public final void registerWorld(World par1World)
{
this.worldObj = par1World;
this.terrainType = par1World.getWorldInfo().getTerrainType();
this.registerWorldChunkManager();
this.generateLightBrightnessTable();
}

/**
* Creates the light to brightness table
*/
protected void generateLightBrightnessTable()
{
float var1 = 0.0F;

for (int var2 = 0; var2 <= 15; ++var2)
{
float var3 = 1.0F - (float)var2 / 15.0F;
this.lightBrightnessTable[var2] = (1.0F - var3) / (var3 * 3.0F + 1.0F) * (1.0F - var1) + var1;
}
}

/**
* creates a new world chunk manager for WorldProvider
*/
protected void registerWorldChunkManager()
{
this.worldChunkMgr = this.terrainType.getChunkManager(this.worldObj);
}

/**
* Returns the chunk provider back for the world provider
*/
public IChunkProvider getChunkProvider()
{
return this.terrainType.getChunkGenerator(this.worldObj);
}

/**
* Will check if the x, z position specified is alright to be set as the map spawn point
*/
public boolean canCoordinateBeSpawn(int par1, int par2)
{
int var3 = this.worldObj.getFirstUncoveredBlock(par1, par2);
return var3 == Block.glass.blockID;
}

/**
* Calculates the angle of sun and moon in the sky relative to a specified time (usually worldTime)
*/
public float calculateCelestialAngle(long par1, float par3)
{
int var4 = (int)(par1 % 24000L);
float var5 = ((float)var4 + par3) / 24000.0F - 0.25F;

if (var5 < 0.0F)
{
++var5;
}

if (var5 > 1.0F)
{
--var5;
}

float var6 = var5;
var5 = 1.0F - (float)((Math.cos((double)var5 * Math.PI) + 1.0D) / 2.0D);
var5 = var6 + (var5 - var6) / 3.0F;
return var5;
}

public int getMoonPhase(long par1, float par3)
{
return (int)(par1 / 24000L) % 8;
}

/**
* Returns 'true' if in the "main surface world", but 'false' if in the Nether or End dimensions.
*/
public boolean isSurfaceWorld()
{
return true;
}

/**
* Returns array with sunrise/sunset colors
*/
public float[] calcSunriseSunsetColors(float par1, float par2)
{
float var3 = 0.4F;
float var4 = MathHelper.cos(par1 * (float)Math.PI * 2.0F) - 0.0F;
float var5 = -0.0F;

if (var4 >= var5 - var3 && var4 <= var5 + var3)
{
float var6 = (var4 - var5) / var3 * 0.5F + 0.5F;
float var7 = 1.0F - (1.0F - MathHelper.sin(var6 * (float)Math.PI)) * 0.99F;
var7 *= var7;
this.colorsSunriseSunset[0] = var6 * 0.3F + 0.7F;
this.colorsSunriseSunset[1] = var6 * var6 * 0.7F + 0.2F;
this.colorsSunriseSunset[2] = var6 * var6 * 0.0F + 0.2F;
this.colorsSunriseSunset[3] = var7;
return this.colorsSunriseSunset;
}
else
{
return null;
}
}

/**
* Return Vec3D with biome specific fog color
*/
public Vec3 getFogColor(float par1, float par2)
{
float var3 = MathHelper.cos(par1 * (float)Math.PI * 2.0F) * 2.0F + 0.5F;

if (var3 < 0.0F)
{
var3 = 0.0F;
}

if (var3 > 1.0F)
{
var3 = 1.0F;
}

float var4 = 0.7529412F;
float var5 = 0.84705883F;
float var6 = 1.0F;
var4 *= var3 * 0.94F + 0.06F;
var5 *= var3 * 0.94F + 0.06F;
var6 *= var3 * 0.91F + 0.09F;
return Vec3.getVec3Pool().getVecFromPool((double)var4, (double)var5, (double)var6);
}

/**
* True if the player can respawn in this dimension (true = overworld, false = nether).
*/
public boolean canRespawnHere()
{
return true;
}


/**
* the y level at which clouds are rendered.
*/
public float getCloudHeight()
{
return 128.0F;
}

public boolean isSkyColored()
{
return true;
}

/**
* Gets the hard-coded portal location to use when entering this dimension
*/
public ChunkCoordinates getEntrancePortalLocation()
{
return null;
}

public int getAverageGroundLevel()
{
return this.terrainType.getSeaLevel(this.worldObj);
}

/**
* returns true if this dimension is supposed to display void particles and pull in the far plane based on the
* user's Y offset.
*/
public boolean getWorldHasVoidParticles()
{
return this.terrainType.hasVoidParticles(this.hasNoSky);
}

/**
* Returns a double value representing the Y value relative to the top of the map at which void fog is at its
* maximum. The default factor of 0.03125 relative to 256, for example, means the void fog will be at its maximum at
* (256*0.03125), or 8.
*/
public double getVoidFogYFactor()
{
return this.terrainType.voidFadeMagnitude();
}

/**
* Returns true if the given X,Z coordinate should show environmental fog.
*/
public boolean doesXZShowFog(int par1, int par2)
{
return false;
}

public abstract String func_80007_l();
}

Później opiszę to bardziej bo teraz nie mam czasu.

27.Własny Schodek

Witam, dziś pokaże jak zrobić własne schodki to zaczynajmy:

pierw do mod_NAZWAMODA.java dodaj konstruktor bloku:

public static final Block NAZWA = new BlockNAZWA(ID, 0).setBlockName("NAZWA").setHardness(TWARDOŚĆ).setResistance(WYBUCH);

NAZWA - Zastąp nazwą schodka

TWARDOŚĆ - Zastąp to twardością bloku czyli jak długo musimy kopać na końcu musi być duże F

WYBUCH - Tu wpisz odporność na wybuch na końcu duże F

Ok teraz do funkcji public void load() wklej:

NAZWA.blockIndexInTexture = ModLoader.addOverride("/terrain.png", "/ŚCIEŻKA.png");
ModLoader.registerBlock(NAZWA);
ModLoader.addName(NAZWA, "NAWAWGRZE");
ModLoader.addRecipe(new ItemStack(NAZWA, ILE), new Object [] {"# ", "## ", "###", '#', Block.BLOK
});

ŚCIEŻKA - tu wpisz nazwę pliku textury schodka. Wklej do minecraft.jar

NAZWAWGRZE - Tu wpisz jak schodek będzie się nazywał w grze

ILE - Tu wpisz ile wychodzi schodków do craftowaniu go

BLOK - Tu wpisz nazwę bloku z którego będzie się robiło schodek

Stwórz plik o nazwie BlockNAZWA.java. Jest to plik schodka:

package net.minecraft.src;
import java.util.List;
import java.util.Random;

public class BlockNAZWA extends Block
{
private static final int[][] field_72159_a = new int[][] {{2, 6}, {3, 7}, {2, 3}, {6, 7}, {0, 4}, {1, 5}, {0, 1}, {4, 5}};
private boolean field_72156_cr = false;
private int field_72160_cs = 0;
protected BlockNAZWA(int i, int j)
{
super(i, j, Material.rock);
this.setLightOpacity(255);
this.setCreativeTab(CreativeTabs.tabBlock);
}
/**
* Updates the blocks boundary depending on the blocs current state. Args: world, x, y, z
*/
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4)
{
if (this.field_72156_cr)
{
this.setBlockBounds(0.5F * (float)(this.field_72160_cs % 2), 0.5F * (float)(this.field_72160_cs / 2 % 2), 0.5F * (float)(this.field_72160_cs / 4 % 2), 0.5F + 0.5F * (float)(this.field_72160_cs % 2), 0.5F + 0.5F * (float)(this.field_72160_cs / 2 % 2), 0.5F + 0.5F * (float)(this.field_72160_cs / 4 % 2));
}
else
{
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
}
/**
* Is this block opaque (transparent) and a full 1m cube? This determines whether or not to render the shared face of them
* 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;
}
/**
* The type of render function that is called for this block (stairs are 10)
*/
public int getRenderType()
{
return 10;
}
/**
* if the specified block is in the given AABB, add its collision bounding box to the given list
*/
public void addCollidingBlockToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity)
{
int var8 = par1World.getBlockMetadata(par2, par3, par4);
int var9 = var8 & 3;
float var10 = 0.0F;
float var11 = 0.5F;
float var12 = 0.5F;
float var13 = 1.0F;
if ((var8 & 4) != 0)
{
var10 = 0.5F;
var11 = 1.0F;
var12 = 0.0F;
var13 = 0.5F;
}
this.setBlockBounds(0.0F, var10, 0.0F, 1.0F, var11, 1.0F);
super.addCollidingBlockToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
if (var9 == 0)
{
this.setBlockBounds(0.5F, var12, 0.0F, 1.0F, var13, 1.0F);
super.addCollidingBlockToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
else if (var9 == 1)
{
this.setBlockBounds(0.0F, var12, 0.0F, 0.5F, var13, 1.0F);
super.addCollidingBlockToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
else if (var9 == 2)
{
this.setBlockBounds(0.0F, var12, 0.5F, 1.0F, var13, 1.0F);
super.addCollidingBlockToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
else if (var9 == 3)
{
this.setBlockBounds(0.0F, var12, 0.0F, 1.0F, var13, 0.5F);
super.addCollidingBlockToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 1.0F, 1.0F);
}
/**

public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLiving par5EntityLiving)
{
int var6 = MathHelper.floor_double((double)(par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
int var7 = par1World.getBlockMetadata(par2, par3, par4) & 4;
if (var6 == 0)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 2 | var7);
}
if (var6 == 1)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 1 | var7);
}
if (var6 == 2)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 3 | var7);
}
if (var6 == 3)
{
par1World.setBlockMetadataWithNotify(par2, par3, par4, 0 | var7);
}
}

public void updateBlockMetadata(World par1World, int par2, int par3, int par4, int par5, float par6, float par7, float par8)
{
if (par5 == 0 || par5 != 1 && (double)par7 > 0.5D)
{
int var9 = par1World.getBlockMetadata(par2, par3, par4);
par1World.setBlockMetadataWithNotify(par2, par3, par4, var9 | 4);
}
}
/**
* Ray traces through the blocks collision from start vector to end vector returning a ray trace hit. Args: world,
* x, y, z, startVec, endVec
*/
public MovingObjectPosition collisionRayTrace(World par1World, int par2, int par3, int par4, Vec3 par5Vec3, Vec3 par6Vec3)
{
MovingObjectPosition[] var7 = new MovingObjectPosition[8];
int var8 = par1World.getBlockMetadata(par2, par3, par4);
int var9 = var8 & 3;
boolean var10 = (var8 & 4) == 4;
int[] var11 = field_72159_a[var9 + (var10 ? 4 : 0)];
this.field_72156_cr = true;
int var14;
int var15;
int var16;
for (int var12 = 0; var12 < 8; ++var12)
{
this.field_72160_cs = var12;
int[] var13 = var11;
var14 = var11.length;
for (var15 = 0; var15 < var14; ++var15)
{
var16 = var13[var15];
if (var16 == var12)
{
;
}
}
var7[var12] = super.collisionRayTrace(par1World, par2, par3, par4, par5Vec3, par6Vec3);
}
int[] var21 = var11;
int var24 = var11.length;
for (var14 = 0; var14 < var24; ++var14)
{
var15 = var21[var14];
var7[var15] = null;
}
MovingObjectPosition var23 = null;
double var22 = 0.0D;
MovingObjectPosition[] var25 = var7;
var16 = var7.length;
for (int var17 = 0; var17 < var16; ++var17)
{
MovingObjectPosition var18 = var25[var17];
if (var18 != null)
{
double var19 = var18.hitVec.squareDistanceTo(par6Vec3);
if (var19 > var22)
{
var23 = var18;
var22 = var19;
}
}
}
return var23;
}
}

FORGE:

Wkrótce...

Co będzie:

-Własne miksturki

-Modyfikowanie nethera

-Materiały wybuchowe

-Gui

-Model moba

-Roślina a/b

-Forge

-Nowy Świat

-Własny piecyk

-Zbroja

-Własny łuk

-Wiele innych

Jeśli znaleźliście jakiś błąd prosze go podać pod tematem

Uwaga jeśli nie chcesz lub nie przydał ci się tut to nie stawiaj plusa, bo tak szczerze mówiąc mi nie zależy na nich.

Skipper_ · 29 Listopada 2012

@Up taki temat juz jest ale chyba nie ma wnim jak robic zbroje wiec ten tut jest taki jakby uzupelnieniem tamtego :P

ElDorado123 · 29 Listopada 2012

@UP Im więcej tym lepiej

TenStylowy · 29 Listopada 2012

Czekam na dalszą część

poradnik 9,5/10

ElDorado123 · 29 Listopada 2012

@UP thx

Miecraft Maniak · 29 Listopada 2012

plus dla cb

ElDorado123 · 30 Listopada 2012

@REF

karol202 · 30 Listopada 2012

Taki temat już jest więc po ch***rę zakładasz drugi?! Kto nie rozumie tego drugiego tuta to niech idzie na craftsite.

Miecraft Maniak · 30 Listopada 2012

@Up

Suchaj im więcej takich tematów tym lepiej. Pozatym on ma więcej lekcji i lepiej wytumaczone . Jak jakiś temat ma być usunięty to twój bo kopiujesz od niego i od innych tutków . A ty poprostu się boisz że jego temat jest lepszy od twojego

Na craftsite jest ten sam temat więc komu się chce na craft... Wchodzić jak jest na mpcforum

karol202 · 30 Listopada 2012

@2up debilu, że co niby kopiuję?! Nic nie kopiuję. Jeśli uważasz że kopiuję do daj mi konkretne dowody. Nie wiesz to się zamknij.

Miecraft Maniak · 30 Listopada 2012

Dałnie jebnięty skakanie na bloku i wiele więcej i ty się zamknij pizdo. On pierwszy napisał o tych lekcjach za 20 min... Ty masz te same w tutcie. Twój temat jest zgłoszony jako plagiat

ElDorado123 · 1 Grudnia 2012

@Ref Ja się w to nie mieszam. Uważam że temat karola jest tak samo fajny jak mój

karol202 · 1 Grudnia 2012

Ja też tak uważam.

Lukis07 · 1 Grudnia 2012

Taki temat już jest , lecz przyznam twój ma więcej informacji .

Mam na myśli to , że za pomocą twojego poradnika można zrobić więcej .

ElDorado123 · 1 Grudnia 2012

@Up Dziękuje

Miecraft Maniak · 1 Grudnia 2012

aha

Miecraft Maniak · 3 Grudnia 2012

Mam problem

BartoszKonkol · 4 Grudnia 2012

Bardzo fajne

Dałeś więcej informacji, niż sam byłęm w stanie znaleść w innych poradnikach

Miecraft Maniak · 4 Grudnia 2012

Miecraft Maniak · 5 Grudnia 2012

F5

ElDorado123 · 7 Grudnia 2012

@Up Nie twój temat to nie odświeżaj :P

ElDorado123 · 8 Grudnia 2012

@REF

Xopow · 9 Stycznia 2013

Może ktoś podać wymiary na taki blok jak schody tylko całe płaskie chodzi mi o dachówkę.

Dzięki

AguaMinero · 4 Lutego 2013

@karol202

zgadzam się twój [TUT] jest dużo lepszy, mam na myśli lepiej napisany...

http://www.mpcforum.pl/topic/662370-tut-zaawansowane-tworzenie-modw/ - [tut] karola

polek122333 · 6 Marca 2013

Bardzo dobry tut chciałbym abyś go dalej rozwijał

Zaloguj się

👋 Witaj na MPCForum!

[Tut]Tworzenie Modów do Minecrafta

Rekomendowane odpowiedzi

Zarchiwizowany