Hi.  I am making a IC2 addon, but the API doesn't have enough stuff in it (no Blocks or Items to use in recipes).  I'm trying to decompile IC2 (the dev-deobf version), but I don't know how to (I need it deobfuscate too)).  I'v tried to put IC2 in mcp\src\mods and then running decompile.bat, but it either doesn't work or I don't know where to find the source.  Any help will be greatly appreciated!

A lot of IC2 items and blocks are registered in the Ore Dictionary.

How can I get to those?

If you have ic2 in your mods folder you can use the following in postInit to print all ore registrations.

	for (String ore : OreDictionary.getOreNames())
	{
		System.out.println(ore);
	}

 

If not, it is pretty easy to figure out.

All dusts are registered as "dust" and then the dust type.

Copper Dust: dustCopper

 

Refer to the following for more information on the dictionary.

http://www.minecraftforge.net/wiki/How_to_use_the_ore_dictionary

http://www.minecraftforge.net/wiki/Common_Oredict_names

 

Thank you.  I have decompiled IC2 using mcp (you have to put the mod int the jar, not the mod folder).  There are a few errors, but I fixed all of the expect three in Grid.java.  It seems as those errors stem from Eclipse not being able to find org.ejml.data.DenseMatrix64F and org.ejml.factory.LinearSolverFactory.

 

Errors (and code):

 

 

 

package ic2.core.energy;

import ic2.api.energy.tile.IEnergySink;
import ic2.api.energy.tile.IEnergySource;
import ic2.core.IC2;
import ic2.core.energy.Grid$1;
import ic2.core.energy.StructureCache$Data;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import net.minecraft.tileentity.TileEntity;
import org.ejml.data.DenseMatrix64F;
import org.ejml.factory.LinearSolverFactory;

private StructureCache$Data calculateDistribution()
    {
        long time = System.nanoTime();
        StructureCache$Data data = this.cache.get(this.activeSources, this.activeSinks);

        if (!data.isInitialized)
        {
            data.isInitialized = true;
            this.optimize(data);
            this.determineEmittingNodes(data);
            int size = data.emittingNodes.size();
            data.networkMatrix = new DenseMatrix64F(size, size);
            data.sourceMatrix = new DenseMatrix64F(size, 1);
            data.resultMatrix = new DenseMatrix64F(size, 1);
            this.populateNetworkMatrix(data);
            data.solver = LinearSolverFactory.symmPosDef(size);

            if (!data.solver.setA(data.networkMatrix))
            {
                throw new RuntimeException("incompatible matrix");
            }
        }

        this.populateSourceMatrix(data);
        data.solver.solve(data.sourceMatrix, data.resultMatrix);
        return data;
    }
    
    private void calculateEffects(StructureCache$Data data, Map<TileEntity, Double> changes)
    {
        long time = System.nanoTime();
        Iterator i$ = data.optimizedNodes.values().iterator();

        while (i$.hasNext())
        {
            Node node = (Node)i$.next();
            Node var10000 = (Node)this.nodes.get(Integer.valueOf(node.uid));

            if (node.nodeType != NodeType.Source && node.nodeType == NodeType.Sink && this.activeSinks.contains(Integer.valueOf(node.uid)))
            {
                double sum = 0.0D;
                Iterator i$1 = node.links.iterator();

                while (i$1.hasNext())
                {
                    NodeLink link = (NodeLink)i$1.next();
                    Node neighbor = link.getNeighbor(node);

                    if (neighbor != node)
                    {
                        for (int row = 0; row < data.emittingNodes.size(); ++row)
                        {
                            if (data.emittingNodes.get(row) == neighbor)
                            {
                                sum += data.resultMatrix.get(row) / link.loss;
                                break;
                            }
                        }
                    }
                }

                if (changes.containsKey(node.tile.entity))
                {
                    changes.put(node.tile.entity, Double.valueOf(((Double)changes.get(node.tile.entity)).doubleValue() + sum));
                }
                else
                {
                    changes.put(node.tile.entity, Double.valueOf(sum));
                }
            }
        }

        time = System.nanoTime() - time;
    }

    private void optimize(StructureCache$Data data)
    {
        data.optimizedNodes = new HashMap();
        Iterator removed = this.nodes.values().iterator();
        Node it;

        while (removed.hasNext())
        {
            it = (Node)removed.next();

            if (it.amount > 0.0D || it.nodeType == NodeType.Conductor || it.nodeType == NodeType.Source)
            {
                assert it.nodeType != NodeType.Sink || this.activeSinks.contains(Integer.valueOf(it.uid));

                if (!$assertionsDisabled && it.nodeType == NodeType.Source && !this.activeSources.contains(Integer.valueOf(it.uid)))
                {
                    ;
                }

                data.optimizedNodes.put(Integer.valueOf(it.uid), new Node(it));
            }
        }

        removed = data.optimizedNodes.values().iterator();
        NodeLink neighborSinkCount;
        boolean outputLink;
        Iterator outputNode;
        NodeLink found;

        while (removed.hasNext())
        {
            it = (Node)removed.next();
            ListIterator node = it.links.listIterator();

            while (node.hasNext())
            {
                neighborSinkCount = (NodeLink)node.next();
                Node neighborConductorCount = neighborSinkCount.getNeighbor(it.uid);

                if (neighborConductorCount.nodeType == NodeType.Sink && ((Node)this.nodes.get(Integer.valueOf(neighborConductorCount.uid))).amount <= 0.0D)
                {
                    node.remove();
                }
                else if (neighborSinkCount.nodeA.uid == it.uid)
                {
                    neighborSinkCount.nodeA = (Node)data.optimizedNodes.get(Integer.valueOf(neighborSinkCount.nodeA.uid));
                    neighborSinkCount.nodeB = (Node)data.optimizedNodes.get(Integer.valueOf(neighborSinkCount.nodeB.uid));
                    assert neighborSinkCount.nodeA != null && neighborSinkCount.nodeB != null;
                    HashSet var19 = new HashSet();
                    outputNode = neighborSinkCount.skippedNodes.iterator();

                    while (outputNode.hasNext())
                    {
                        Node var20 = (Node)outputNode.next();
                        var19.add(data.optimizedNodes.get(Integer.valueOf(var20.uid)));
                    }

                    neighborSinkCount.skippedNodes = var19;
                }
                else
                {
                    assert neighborSinkCount.nodeB.uid == it.uid;
                    outputLink = false;
                    outputNode = ((Node)data.optimizedNodes.get(Integer.valueOf(neighborSinkCount.nodeA.uid))).links.iterator();

                    while (outputNode.hasNext())
                    {
                        found = (NodeLink)outputNode.next();
                        assert found.nodeA.uid != it.uid;

                        if (found.nodeB.uid == it.uid)
                        {
                            assert found.nodeA.uid == neighborSinkCount.nodeA.uid;
                            outputLink = true;
                            node.set(found);
                            break;
                        }
                    }

                    assert outputLink;
                }
            }
        }

        int var12;

        do
        {
            var12 = 0;
            Iterator var13 = data.optimizedNodes.values().iterator();

            while (var13.hasNext())
            {
                Node var14 = (Node)var13.next();

                if (var14.nodeType == NodeType.Conductor)
                {
                    NodeLink var18;

                    if (var14.links.size() >= 2)
                    {
                        boolean var23;
                        Node var24;

                        if (var14.links.size() == 2)
                        {
                            var13.remove();
                            ++var12;
                            neighborSinkCount = (NodeLink)var14.links.get(0);
                            var18 = (NodeLink)var14.links.get(1);
                            Node var27 = neighborSinkCount.getNeighbor(var14);
                            var24 = var18.getNeighbor(var14);

                            if (var27 == var24)
                            {
                                var27.links.remove(neighborSinkCount);
                                var24.links.remove(var18);
                            }
                            else
                            {
                                neighborSinkCount.loss += var18.loss;
                                neighborSinkCount.skippedNodes.addAll(var18.skippedNodes);
                                neighborSinkCount.skippedNodes.add(var14);

                                if (neighborSinkCount.nodeA == var14)
                                {
                                    neighborSinkCount.nodeA = var24;
                                }
                                else
                                {
                                    neighborSinkCount.nodeB = var24;
                                }

                                assert neighborSinkCount.nodeA != neighborSinkCount.nodeB;
                                assert neighborSinkCount.nodeA == var27 || neighborSinkCount.nodeB == var27;
                                assert neighborSinkCount.nodeA == var24 || neighborSinkCount.nodeB == var24;
                                var23 = false;
                                ListIterator var26 = var24.links.listIterator();

                                while (var26.hasNext())
                                {
                                    if (var26.next() == var18)
                                    {
                                        var23 = true;
                                        var26.set(neighborSinkCount);
                                        break;
                                    }
                                }

                                assert var23;
                            }
                        }
                        else
                        {
                            int var16 = 0;
                            int var17 = 0;
                            Iterator var21 = var14.links.iterator();

                            while (var21.hasNext())
                            {
                                NodeLink var22 = (NodeLink)var21.next();

                                switch (Grid$1.$SwitchMap$ic2$core$energy$NodeType[var22.getNeighbor(var14).nodeType.ordinal()])
                                {
                                    case 1:
                                    default:
                                        break;

                                    case 2:
                                        ++var16;
                                        break;

                                    case 3:
                                        ++var17;
                                }
                            }

                            if ((var16 == 0 || var17 == 0) && (var16 == 1 || var17 == 1))
                            {
                                var13.remove();
                                ++var12;
                                NodeLink var25 = null;
                                outputNode = var14.links.iterator();

                                while (outputNode.hasNext())
                                {
                                    found = (NodeLink)outputNode.next();
                                    Node i$ = found.getNeighbor(var14);

                                    if (i$.nodeType == NodeType.Sink)
                                    {
                                        var25 = found;
                                        break;
                                    }

                                    if (i$.nodeType == NodeType.Conductor)
                                    {
                                        var25 = found;
                                        break;
                                    }
                                }

                                assert var25 != null;
                                var24 = var25.getNeighbor(var14);
                                var23 = false;
                                Iterator var28 = var24.links.iterator();

                                while (var28.hasNext())
                                {
                                    if (var28.next() == var25)
                                    {
                                        var23 = true;
                                        var28.remove();
                                        break;
                                    }
                                }

                                assert var23;
                                var28 = var14.links.iterator();

                                while (var28.hasNext())
                                {
                                    NodeLink link = (NodeLink)var28.next();

                                    if (link != var25)
                                    {
                                        if (link.nodeA == var14)
                                        {
                                            link.nodeA = var24;
                                        }
                                        else if (link.nodeB == var14)
                                        {
                                            link.nodeB = var24;
                                        }

                                        link.loss += var25.loss;
                                        link.skippedNodes.addAll(var25.skippedNodes);
                                        link.skippedNodes.add(var14);
                                        var24.links.add(link);
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        var13.remove();
                        ++var12;
                        Iterator var15 = var14.links.iterator();

                        while (var15.hasNext())
                        {
                            var18 = (NodeLink)var15.next();
                            outputLink = false;
                            outputNode = var18.getNeighbor(var14).links.iterator();

                            while (true)
                            {
                                if (outputNode.hasNext())
                                {
                                    if (outputNode.next() != var18)
                                    {
                                        continue;
                                    }

                                    outputLink = true;
                                    outputNode.remove();
                                }

                                assert outputLink;
                                break;
                            }
                        }
                    }
                }
            }
        }
        while (var12 > 0);
    }
    
    private void populateNetworkMatrix(StructureCache$Data data)
    {
        for (int row = 0; row < data.emittingNodes.size(); ++row)
        {
            Node node = (Node)data.emittingNodes.get(row);

            for (int col = 0; col < data.emittingNodes.size(); ++col)
            {
                double value = 0.0D;

                if (row == col)
                {
                    Iterator possibleNeighbor = node.links.iterator();

                    while (possibleNeighbor.hasNext())
                    {
                        NodeLink i$ = (NodeLink)possibleNeighbor.next();

                        if (i$.getNeighbor(node) != node)
                        {
                            value += 1.0D / i$.loss;
                        }
                    }
                }
                else
                {
                    Node var11 = (Node)data.emittingNodes.get(col);
                    Iterator var12 = node.links.iterator();

                    while (var12.hasNext())
                    {
                        NodeLink link = (NodeLink)var12.next();
                        Node neighbor = link.getNeighbor(node);

                        if (neighbor != node && neighbor == var11)
                        {
                            value -= 1.0D / link.loss;
                        }
                    }
                }

                data.networkMatrix.set(row, col, value);
            }
        }
    }
    
    private void populateSourceMatrix(StructureCache$Data data)
    {
        for (int row = 0; row < data.emittingNodes.size(); ++row)
        {
            Node node = (Node)data.emittingNodes.get(row);
            double input = 0.0D;

            if (node.nodeType == NodeType.Source)
            {
                Node realNode = (Node)this.nodes.get(Integer.valueOf(node.uid));
                input = realNode.amount;
            }

            data.sourceMatrix.set(row, 0, input);
        }
    }
    
    
    void dumpMatrix(PrintStream ps)
    {
        this.finishCalculation();
        ps.println("dumping matrices for " + this);
        StructureCache$Data data = this.cache.get(this.activeSources, this.activeSinks);

        if (data.isInitialized && data.networkMatrix != null && data.sourceMatrix != null && data.resultMatrix != null)
        {
            ps.println("emitting node indizes:");

            for (int i = 0; i < data.emittingNodes.size(); ++i)
            {
                Node node = (Node)data.emittingNodes.get(i);
                ps.println(i + " " + node + " (amount=" + ((Node)this.nodes.get(Integer.valueOf(node.uid))).amount + ")");
            }

            ps.println("network matrix:");
            ps.print(data.networkMatrix.toString());
            ps.println("source matrix:");
            ps.print(data.sourceMatrix.toString());
            ps.println("result matrix:");
            ps.print(data.resultMatrix.toString());
        }
        else
        {
            ps.println("matrixes unavailable");
        }
    }
    
    
    
[\code]
[\spoiler]

You dont have to decompile it... Just get the IC2 mod zip and place it in mods like you would in a normal minecraft installation.

Then you can use IC2 items in the game but not in the code (at least I think).

Like I said, use the Ore Dictionary along with the api for the actual code. The mod is there for testing purposes. Otherwise there would be no dictionary registrations.

For one, ic2 dusts are no longer dusts, and in the ore dictionary crushed iron, as it is now called, is crushedIron. Additionally, I recommend using the API given by IC2 to actually make the mod, but decompile the source with JD-GUI if you want to look at examples on how to do it.