Ejemplo n.º 1
0
    public static void LoadAllChips(string[] chipPaths, Manager manager)
    {
        SavedChip[] savedChips = GetAllSavedChips(chipPaths);

        SortChipsByOrderOfCreation(ref savedChips);
        // Maintain dictionary of loaded chips (initially just the built-in chips)
        Dictionary <string, Chip> loadedChips = new Dictionary <string, Chip> ();

        for (int i = 0; i < manager.builtinChips.Length; i++)
        {
            Chip builtinChip = manager.builtinChips[i];
            loadedChips.Add(builtinChip.chipName, builtinChip);
        }
        for (int i = 0; i < savedChips.Length; i++)
        {
            SavedChip    chipToTryLoad  = savedChips[i];
            ChipSaveData loadedChipData = LoadChip(chipToTryLoad, loadedChips, manager.wirePrefab);
            Chip         loadedChip     = manager.LoadChip(loadedChipData);
            if (loadedChip is CustomChip custom)
            {
                custom.ApplyWireModes();
            }
            loadedChips.Add(loadedChip.chipName, loadedChip);
        }
    }
Ejemplo n.º 2
0
    public static void Save(ChipEditor chipEditor)
    {
        ChipSaveData chipSaveData = new ChipSaveData(chipEditor);

        // Generate new chip save string
        var    compositeChip = new SavedChip(chipSaveData);
        string saveString    = JsonUtility.ToJson(compositeChip, usePrettyPrint);

        // Generate save string for wire layout
        var    wiringSystem     = new SavedWireLayout(chipSaveData);
        string wiringSaveString = JsonUtility.ToJson(wiringSystem, usePrettyPrint);

        // Write to file
        string savePath = SaveSystem.GetPathToSaveFile(chipEditor.chipName);

        using (StreamWriter writer = new StreamWriter(savePath))
        {
            writer.Write(saveString);
        }

        string wireLayoutSavePath = SaveSystem.GetPathToWireSaveFile(chipEditor.chipName);

        using (StreamWriter writer = new StreamWriter(wireLayoutSavePath))
        {
            writer.Write(wiringSaveString);
        }
    }
Ejemplo n.º 3
0
    public void LoadFromSaveData(ChipSaveData saveData)
    {
        chipName       = saveData.chipName;
        chipColour     = saveData.chipColour;
        chipNameColour = saveData.chipNameColour;
        creationIndex  = saveData.creationIndex;

        // Load component chips
        for (int i = 0; i < saveData.componentChips.Length; i++)
        {
            Chip componentChip = saveData.componentChips[i];
            if (componentChip as InputSignal)
            {
                inputsEditor.LoadSignal(componentChip as InputSignal);
            }
            else if (componentChip as OutputSignal)
            {
                outputsEditor.LoadSignal(componentChip as OutputSignal);
            }
            else
            {
                chipInteraction.LoadChip(componentChip);
            }
        }

        // Load wires
        if (saveData.wires != null)
        {
            for (int i = 0; i < saveData.wires.Length; i++)
            {
                pinAndWireInteraction.LoadWire(saveData.wires[i]);
            }
        }
    }
Ejemplo n.º 4
0
    public static void LoadAllChips(string[] chipPaths, Manager manager)
    {
        SavedChip[] savedChips = new SavedChip[chipPaths.Length];

        // Read saved chips from file
        for (int i = 0; i < chipPaths.Length; i++)
        {
            using (StreamReader reader = new StreamReader(chipPaths[i])) {
                string chipSaveString = reader.ReadToEnd();
                savedChips[i] = JsonUtility.FromJson <SavedChip> (chipSaveString);
            }
        }

        SortChipsByOrderOfCreation(ref savedChips);
        // Maintain dictionary of loaded chips (initially just the built-in chips)
        Dictionary <string, Chip> loadedChips = new Dictionary <string, Chip> ();

        for (int i = 0; i < manager.builtinChips.Length; i++)
        {
            Chip builtinChip = manager.builtinChips[i];
            loadedChips.Add(builtinChip.chipName, builtinChip);
        }

        for (int i = 0; i < savedChips.Length; i++)
        {
            SavedChip    chipToTryLoad  = savedChips[i];
            ChipSaveData loadedChipData = LoadChip(chipToTryLoad, loadedChips, manager.wirePrefab);
            Chip         loadedChip     = manager.LoadChip(loadedChipData);
            loadedChips.Add(loadedChip.chipName, loadedChip);
        }
    }
Ejemplo n.º 5
0
    public void ViewChip(Chip chip)
    {
        LoadNewEditor();
        UIManager.ChangeState(UIManagerState.Update);

        ChipSaveData chipSaveData = ChipLoader.GetChipSaveData(chip, builtinChips, spawnableChips, wirePrefab, activeChipEditor);

        activeChipEditor.LoadFromSaveData(chipSaveData);
    }
Ejemplo n.º 6
0
    public static ChipSaveData GetChipSaveData(Chip chip, Chip[] builtinChips, List <Chip> spawnableChips, Wire wirePrefab, ChipEditor chipEditor)
    {
        // @NOTE: chipEditor can be removed here if:
        //     * Chip & wire instatiation is inside their respective implementation holders is inside the chipEditor
        //     * the wire connections are done inside ChipEditor.LoadFromSaveData instead of ChipLoader.LoadChipWithWires

        SavedChip chipToTryLoad;

        SavedChip[] savedChips = SaveSystem.GetAllSavedChips();

        using (StreamReader reader = new StreamReader(SaveSystem.GetPathToSaveFile(chip.name)))
        {
            string chipSaveString = reader.ReadToEnd();
            chipToTryLoad = JsonUtility.FromJson <SavedChip>(chipSaveString);
        }

        if (chipToTryLoad == null)
        {
            return(null);
        }

        SortChipsByOrderOfCreation(ref savedChips);
        // Maintain dictionary of loaded chips (initially just the built-in chips)
        Dictionary <string, Chip> loadedChips = new Dictionary <string, Chip> ();

        for (int i = 0; i < builtinChips.Length; i++)
        {
            Chip builtinChip = builtinChips[i];
            loadedChips.Add(builtinChip.chipName, builtinChip);
        }
        foreach (Chip loadedChip in spawnableChips)
        {
            if (loadedChips.ContainsKey(loadedChip.chipName))
            {
                continue;
            }
            loadedChips.Add(loadedChip.chipName, loadedChip);
        }

        ChipSaveData    loadedChipData = LoadChipWithWires(chipToTryLoad, loadedChips, wirePrefab, chipEditor);
        SavedWireLayout wireLayout     = LoadWiringFile(SaveSystem.GetPathToWireSaveFile(loadedChipData.chipName));

        // Set wires anchor points
        for (int i = 0; i < wireLayout.serializableWires.Length; i++)
        {
            string startPinName = loadedChipData.componentChips[wireLayout.serializableWires[i].parentChipIndex].outputPins[wireLayout.serializableWires[i].parentChipOutputIndex].pinName;
            string endPinName   = loadedChipData.componentChips[wireLayout.serializableWires[i].childChipIndex].inputPins[wireLayout.serializableWires[i].childChipInputIndex].pinName;

            int wireIndex = Array.FindIndex(loadedChipData.wires, w => w.startPin.pinName == startPinName && w.endPin.pinName == endPinName);
            if (wireIndex >= 0)
            {
                loadedChipData.wires[wireIndex].SetAnchorPoints(wireLayout.serializableWires[i].anchorPoints);
            }
        }

        return(loadedChipData);
    }
Ejemplo n.º 7
0
    public Chip LoadChip(ChipSaveData loadedChipData)
    {
        activeChipEditor.LoadFromSaveData(loadedChipData);
        currentChipCreationIndex = activeChipEditor.creationIndex;

        Chip loadedChip = PackageChip();

        LoadNewEditor();
        return(loadedChip);
    }
Ejemplo n.º 8
0
    public SavedWireLayout(ChipSaveData chipSaveData)
    {
        Wire[] allWires = chipSaveData.wires;
        serializableWires = new SavedWire[allWires.Length];

        for (int i = 0; i < allWires.Length; i++)
        {
            serializableWires[i] = new SavedWire(chipSaveData, allWires[i]);
        }
    }
Ejemplo n.º 9
0
    public SavedWire(ChipSaveData chipSaveData, Wire wire)
    {
        Pin parentPin = wire.startPin;
        Pin childPin  = wire.endPin;

        parentChipIndex       = chipSaveData.ComponentChipIndex(parentPin.chip);
        parentChipOutputIndex = parentPin.index;

        childChipIndex      = chipSaveData.ComponentChipIndex(childPin.chip);
        childChipInputIndex = childPin.index;

        anchorPoints = wire.anchorPoints.ToArray();
    }
Ejemplo n.º 10
0
 public SavedInputPin(ChipSaveData chipSaveData, Pin pin)
 {
     name    = pin.pinName;
     isCylic = pin.cyclic;
     if (pin.parentPin)
     {
         parentChipIndex       = chipSaveData.ComponentChipIndex(pin.parentPin.chip);
         parentChipOutputIndex = pin.parentPin.index;
     }
     else
     {
         parentChipIndex       = -1;
         parentChipOutputIndex = -1;
     }
 }
Ejemplo n.º 11
0
    public SavedChip(ChipSaveData chipSaveData)
    {
        name          = chipSaveData.chipName;
        creationIndex = chipSaveData.creationIndex;
        colour        = chipSaveData.chipColour;
        nameColour    = chipSaveData.chipNameColour;

        // Create list of (unique) names of all chips used to make this chip
        componentNameList = chipSaveData.componentChips.Select(x => x.chipName).Distinct().ToArray();

        // Create serializable chips
        savedComponentChips = new SavedComponentChip[chipSaveData.componentChips.Length];
        for (int i = 0; i < chipSaveData.componentChips.Length; i++)
        {
            savedComponentChips[i] = new SavedComponentChip(chipSaveData, chipSaveData.componentChips[i]);
        }
    }
Ejemplo n.º 12
0
    public SavedComponentChip(ChipSaveData chipSaveData, Chip chip)
    {
        chipName = chip.chipName;

        // Store position in doubles and limit precision to reduce space in save file
        const double precision = 10000;

        posX = ((int)(chip.transform.position.x * precision)) / precision;
        posY = ((int)(chip.transform.position.y * precision)) / precision;

        // Input pins
        inputPins = new SavedInputPin[chip.inputPins.Length];
        for (int i = 0; i < inputPins.Length; i++)
        {
            inputPins[i] = new SavedInputPin(chipSaveData, chip.inputPins[i]);
        }

        // Output pins (only need to store names, connections are stored on input pins only)
        outputPinNames = new string[chip.outputPins.Length];
        for (int i = 0; i < chip.outputPins.Length; i++)
        {
            outputPinNames[i] = chip.outputPins[i].pinName;
        }
    }
Ejemplo n.º 13
0
 public static void EditSavedChip(SavedChip savedChip, ChipSaveData chipSaveData)
 {
 }
Ejemplo n.º 14
0
    public static void Update(ChipEditor chipEditor, Chip chip)
    {
        ChipSaveData chipSaveData = new ChipSaveData(chipEditor);

        // Generate new chip save string
        var    compositeChip = new SavedChip(chipSaveData);
        string saveString    = JsonUtility.ToJson(compositeChip, usePrettyPrint);

        // Generate save string for wire layout
        var    wiringSystem     = new SavedWireLayout(chipSaveData);
        string wiringSaveString = JsonUtility.ToJson(wiringSystem, usePrettyPrint);

        // Write to file
        string savePath = SaveSystem.GetPathToSaveFile(chipEditor.chipName);

        using (StreamWriter writer = new StreamWriter(savePath))
        {
            writer.Write(saveString);
        }

        string wireLayoutSavePath = SaveSystem.GetPathToWireSaveFile(chipEditor.chipName);

        using (StreamWriter writer = new StreamWriter(wireLayoutSavePath))
        {
            writer.Write(wiringSaveString);
        }

        // Update parent chips using this chip
        string currentChipName = chipEditor.chipName;

        SavedChip[] savedChips = SaveSystem.GetAllSavedChips();
        for (int i = 0; i < savedChips.Length; i++)
        {
            if (savedChips[i].componentNameList.Contains(currentChipName))
            {
                int currentChipIndex = Array.FindIndex(savedChips[i].savedComponentChips, c => c.chipName == currentChipName);
                SavedComponentChip updatedComponentChip = new SavedComponentChip(chipSaveData, chip);
                SavedComponentChip oldComponentChip     = savedChips[i].savedComponentChips[currentChipIndex];

                // Update component chip I/O
                for (int j = 0; j < updatedComponentChip.inputPins.Length; j++)
                {
                    for (int k = 0; k < oldComponentChip.inputPins.Length; k++)
                    {
                        if (updatedComponentChip.inputPins[j].name == oldComponentChip.inputPins[k].name)
                        {
                            updatedComponentChip.inputPins[j].parentChipIndex       = oldComponentChip.inputPins[k].parentChipIndex;
                            updatedComponentChip.inputPins[j].parentChipOutputIndex = oldComponentChip.inputPins[k].parentChipOutputIndex;
                            updatedComponentChip.inputPins[j].isCylic = oldComponentChip.inputPins[k].isCylic;
                        }
                    }
                }

                // Write to file
                string parentSaveString = JsonUtility.ToJson(savedChips[i], usePrettyPrint);
                string parentSavePath   = SaveSystem.GetPathToSaveFile(savedChips[i].name);
                using (StreamWriter writer = new StreamWriter(parentSavePath))
                {
                    writer.Write(parentSaveString);
                }
            }
        }
    }
Ejemplo n.º 15
0
    // Instantiates all components that make up the given clip, and connects them up with wires
    // The components are parented under a single "holder" object, which is returned from the function
    static ChipSaveData LoadChip(SavedChip chipToLoad, Dictionary <string, Chip> previouslyLoadedChips, Wire wirePrefab)
    {
        ChipSaveData loadedChipData = new ChipSaveData();
        int          numComponents  = chipToLoad.savedComponentChips.Length;

        loadedChipData.componentChips = new Chip[numComponents];
        loadedChipData.chipName       = chipToLoad.name;
        loadedChipData.chipColour     = chipToLoad.colour;
        loadedChipData.chipNameColour = chipToLoad.nameColour;
        loadedChipData.creationIndex  = chipToLoad.creationIndex;

        // Spawn component chips (the chips used to create this chip)
        // These will have been loaded already, and stored in the previouslyLoadedChips dictionary
        for (int i = 0; i < numComponents; i++)
        {
            SavedComponentChip componentToLoad = chipToLoad.savedComponentChips[i];
            string             componentName   = componentToLoad.chipName;
            Vector2            pos             = new Vector2((float)componentToLoad.posX, (float)componentToLoad.posY);

            if (!previouslyLoadedChips.ContainsKey(componentName))
            {
                Debug.LogError("Failed to load sub component: " + componentName + " While loading " + chipToLoad.name);
            }

            Chip loadedComponentChip = GameObject.Instantiate(previouslyLoadedChips[componentName], pos, Quaternion.identity);
            loadedChipData.componentChips[i] = loadedComponentChip;

            // Load input pin names
            for (int inputIndex = 0; inputIndex < componentToLoad.inputPins.Length; inputIndex++)
            {
                loadedChipData.componentChips[i].inputPins[inputIndex].pinName = componentToLoad.inputPins[inputIndex].name;
            }

            // Load output pin names
            for (int ouputIndex = 0; ouputIndex < componentToLoad.outputPinNames.Length; ouputIndex++)
            {
                loadedChipData.componentChips[i].outputPins[ouputIndex].pinName = componentToLoad.outputPinNames[ouputIndex];
            }
        }

        // Connect pins with wires
        for (int chipIndex = 0; chipIndex < chipToLoad.savedComponentChips.Length; chipIndex++)
        {
            Chip loadedComponentChip = loadedChipData.componentChips[chipIndex];
            for (int inputPinIndex = 0; inputPinIndex < loadedComponentChip.inputPins.Length; inputPinIndex++)
            {
                SavedInputPin savedPin = chipToLoad.savedComponentChips[chipIndex].inputPins[inputPinIndex];
                Pin           pin      = loadedComponentChip.inputPins[inputPinIndex];

                // If this pin should receive input from somewhere, then wire it up to that pin
                if (savedPin.parentChipIndex != -1)
                {
                    Pin connectedPin = loadedChipData.componentChips[savedPin.parentChipIndex].outputPins[savedPin.parentChipOutputIndex];
                    pin.cyclic = savedPin.isCylic;
                    Pin.TryConnect(connectedPin, pin);
                    //if (Pin.TryConnect (connectedPin, pin)) {
                    //Wire loadedWire = GameObject.Instantiate (wirePrefab, parent : chipHolder);
                    //loadedWire.Connect (connectedPin, loadedComponentChip.inputPins[inputPinIndex]);
                    //}
                }
            }
        }

        return(loadedChipData);
    }
Ejemplo n.º 16
0
 public SavedOutputPin(ChipSaveData chipSaveData, Pin pin)
 {
     name     = pin.pinName;
     wireType = pin.wireType;
 }