Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

Help with IC2 addon


AskHow1248
 Share

Recommended Posts

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!

Link to comment
Share on other sites

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

 

Link to comment
Share on other sites

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]

Link to comment
Share on other sites

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.

If you really want help, give that modder a thank you.

 

Modders LOVE thank yous.

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share

×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.