Help with IC2 addon

[AskHow1248]

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!

[CJLetsGame]

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

[AskHow1248]

How can I get to those?

[CJLetsGame]

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

 

[AskHow1248]

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]

[CJLetsGame]

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.

[AskHow1248]

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

[CJLetsGame]

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.

[mardiff]

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.