Beispiel #1
0
    //
    // Public Methods
    //

    public void Init(GridData grid, PlanningOutput planningOutput)
    {
        this.grid           = grid;
        this.planningOutput = planningOutput;

        // Find Components
        map = ComponentManager.Instance.Get <MapController>();
        var canvas = GameObject.FindWithTag("Canvas").GetComponent <Canvas>();

        // Create pin container (inside map)
        pinContainer = new GameObject("PinContainer").transform;
        pinContainer.SetParent(map.transform, false);

        // Create flag container (inside UI canvas)
        flagContainer      = Instantiate(flagContainerPrefab, canvas.transform, false);
        flagContainer.name = flagContainerPrefab.name;
        flagContainer.transform.SetSiblingIndex(0);

        // Create summary flag container (inside UI canvas)
        summaryflagContainer      = Instantiate(flagContainerPrefab, canvas.transform, false);
        summaryflagContainer.name = "Summary" + flagContainerPrefab.name;
        summaryflagContainer.transform.SetSiblingIndex(0);

        // Create summary pin/flag
        summaryPanelFlag = Instantiate(summaryPanelPrefab, summaryflagContainer, false);
        summaryPanelFlag.Init("SummaryPanelFlag", grid, 3);
        summaryPanelFlag.SetPlanningOutput(planningOutput);
        summaryPanelFlag.gameObject.SetActive(showFlags);
        summaryPin = Instantiate(summaryPinPrefab, pinContainer, true);
        summaryPin.Init(Coordinate.Zero, groupPins, summaryPanelFlag);

        // Attach to events
        map.OnMapUpdate += OnMapUpdate;
    }
Beispiel #2
0
    private void OnDestroy()
    {
        // Detach from events
        map.OnMapUpdate -= OnMapUpdate;
        dataLayers.OnLayerVisibilityChange -= OnLayerVisibilityChange;

        // Stop coroutines
        if (drawingArea != null)
        {
            StopCoroutine(drawingArea);
        }

        if (planningOutputPanel != null)
        {
            outputPanel.DestroyPanel(planningOutputPanel.gameObject);
            planningOutputPanel = null;
        }

        // Clear icons
        foreach (var cell in planningCells)
        {
            cell.ClearIcon();
        }

        // Destroy pulsating cell
        if (pulsatingCell != null)
        {
            Destroy(pulsatingCell.gameObject);
            pulsatingCell = null;
        }

        // Destroy containers
        if (iconContainer != null)
        {
            Destroy(iconContainer.gameObject);
            iconContainer = null;
        }

        if (flagger != null)
        {
            Destroy(flagger.gameObject);
            flagger = null;
        }

        // Destroy materials
        foreach (var mat in materialsMap)
        {
            Destroy(mat.Value);
        }

        // Clear list and maps
        typologiesMap.Clear();
        materialsMap.Clear();
        planningCells.Clear();
        planningCellsMap.Clear();
        planningGroups.Clear();
    }
Beispiel #3
0
    //
    // Public Methods
    //

    public void Init(PlanningOutput planningOutput)
    {
        this.planningOutput = planningOutput;
        translator          = LocalizationManager.Instance;

        var unitsDropdown = this.planningOutput.unitsDropdown;

        OnUnitsChanged(unitsDropdown.value);

        unitsDropdown.onValueChanged.RemoveListener(OnUnitsChanged);
        unitsDropdown.onValueChanged.AddListener(OnUnitsChanged);
    }
Beispiel #4
0
    public void Init(TypologyLibrary typologyLibrary, GridData grid, List <Typology> typologies)
    {
        this.grid       = grid;
        this.typologies = typologies;

        dataLayers.OnLayerVisibilityChange += OnLayerVisibilityChange;

        // Create typologies map
        foreach (var entry in typologyLibrary.typologies)
        {
            typologiesMap.Add(entry.name, entry);
        }

        // Cache grid transformations
        gridCoordsToCell = new Distance(grid.countX / (grid.east - grid.west), grid.countY / (grid.south - grid.north));
        gridCellToCoords = new Distance((grid.east - grid.west) / grid.countX, (grid.south - grid.north) / grid.countY);

        // Create pulsating cell (inside map)
        pulsatingCell      = Instantiate(pulsatingCellPrefab, map.transform, false);
        pulsatingCell.name = pulsatingCellPrefab.name;
        pulsatingCell.Init((float)(gridCellToCoords.x * GeoCalculator.Deg2Meters));

        // Create icon container (inside map)
        iconContainer = new GameObject("Typology Icons").transform;
        iconContainer.SetParent(map.transform, false);

        // Attach to events
        map.OnMapUpdate += OnMapUpdate;

        // Update output panel
        planningOutputPanel = Instantiate(outputPrefab);
        planningOutputPanel.Init();
        planningOutputPanel.name = outputPrefab.name;
        planningOutputPanel.SetTypologies(typologies);
        planningOutputPanel.SetTargetValues(targetValues);
        SetOutput();
        planningOutputPanel.UpdateOutput();

        // Create flagger
        flagger      = Instantiate(flaggerPrefab);
        flagger.name = flaggerPrefab.name;
        flagger.Init(grid, planningOutputPanel);
    }
Beispiel #5
0
 public void SetPlanningOutput(PlanningOutput planningOutput)
 {
     this.planningOutput = planningOutput;
 }