Exemple #1
0
    public void CollectResource(Tile.TileTypes type, int amount)
    {
        switch (type)
        {
        case Tile.TileTypes.SOCIAL:
            Social += amount;
            txtSocial.GetComponent <Animator>().SetTrigger("ResourceGet");
            break;

        case Tile.TileTypes.HEALTH:
            Health += amount;
            txtHealth.GetComponent <Animator>().SetTrigger("ResourceGet");
            break;

        case Tile.TileTypes.MONEY:
            Money += amount;
            txtMoney.GetComponent <Animator>().SetTrigger("ResourceGet");
            break;

        case Tile.TileTypes.TIME:
            Time += amount;
            txtTime.GetComponent <Animator>().SetTrigger("ResourceGet");
            break;

        default:
            break;
        }

        UpdateStats();
    }
    override public void Construct(BuildingTypes bt, Tile t, GameManager gm)
    {
        if (Building.neighborsScaleEfficiency.Contains(bt))
        {
            Tile.TileTypes nt            = Building.Neighbor_Type[bt];
            int            m1            = Building.Neighbor_minmax[bt].Item1;
            int            m2            = Building.Neighbor_minmax[bt].Item2;
            int            neighborCount = 0;
            foreach (Tile n in t._neighborTiles)
            {
                if (n._type == nt)
                {
                    neighborCount++;
                }
            }
        }

        GM          = gm;
        _jobManager = gm.gameObject.GetComponent(typeof(JobManager)) as JobManager;
        _type       = bt;
        t._building = this;
        _tile       = t;
        GM._buildings.Add(this);
        //deducting resources used in construction
        GM._resourcesInWarehouse[GameManager.ResourceTypes.Planks] -= Building.cost_plank[bt];
        GM._money -= Building.cost_money[bt];
    }
Exemple #3
0
 public bool CanBeBuiltOn(Tile.TileTypes tile)
 {
     if (tile == Tile.TileTypes.Water)
     {
         return(water_can_be_built_on);
     }
     if (tile == Tile.TileTypes.Sand)
     {
         return(sand_can_be_built_on);
     }
     if (tile == Tile.TileTypes.Grass)
     {
         return(grass_can_be_built_on);
     }
     if (tile == Tile.TileTypes.Forest)
     {
         return(forest_can_be_built_on);
     }
     if (tile == Tile.TileTypes.Stone)
     {
         return(stone_can_be_built_on);
     }
     if (tile == Tile.TileTypes.Mountain)
     {
         return(mountain_can_be_built_on);
     }
     return(false);
 }
Exemple #4
0
 override public void Construct(BuildingTypes bt, Tile t, GameManager gm)
 {
     _placementEfficiency = 1f;
     if (ProductionBuilding.neighborsScaleEfficiency.Contains(bt))
     {
         Tile.TileTypes nt            = ProductionBuilding.Neighbor_Type[bt];
         int            m1            = ProductionBuilding.Neighbor_minmax[bt].Item1;
         int            m2            = ProductionBuilding.Neighbor_minmax[bt].Item2;
         int            neighborCount = 0;
         foreach (Tile n in t._neighborTiles)
         {
             if (n._type == nt)
             {
                 neighborCount++;
             }
         }
         _placementEfficiency = Math.Max(0f, Math.Min(1f, (float)(1 + neighborCount - m1) / (float)(1 + m2 - m1)));//calculates efficiency factor
     }
     waitTime    = ProductionBuilding.resourceGeneration[bt];
     GM          = gm;
     _jobManager = gm.gameObject.GetComponent(typeof(JobManager)) as JobManager;
     _type       = bt;
     t._building = this;
     GM._buildings.Add(this);
     _tile = t;
     //deducting resources used in construction
     GM._resourcesInWarehouse[GameManager.ResourceTypes.Planks] -= Building.cost_plank[bt];
     GM._money -= Building.cost_money[bt];
 }
Exemple #5
0
    public static bool Constructable(BuildingTypes bt, Tile t, GameManager GM)
    {
        bool placeable = true;

        UnityEngine.Debug.Assert(GM._buildingPrefabs.Dict.ContainsKey(bt), "Building Type has no model assigned.", GM);
        UnityEngine.Debug.Assert(t._building is null, "This spot allready has a building.", GM);
        //determines if building is placed on right tile.
        UnityEngine.Debug.Assert(Building.TileOptions.ContainsKey(bt), "Building has no tile type assigned.", GM);
        UnityEngine.Debug.Assert(Building.TileOptions[bt].Contains(t._type), "Building can't be placed on this tile type.", GM);
        UnityEngine.Debug.Assert(GM._resourcesInWarehouse[GameManager.ResourceTypes.Planks] >= Building.cost_plank[bt], "Not enough planks.", GM);
        UnityEngine.Debug.Assert(GM._money >= Building.cost_money[bt], "Not enough money.", GM);
        if (Building.neighborsScaleEfficiency.Contains(bt))
        {
            Tile.TileTypes nt            = Building.Neighbor_Type[bt];
            int            m1            = Building.Neighbor_minmax[bt].Item1;
            int            neighborCount = 0;
            foreach (Tile n in t._neighborTiles)
            {
                if (n._type == nt)
                {
                    neighborCount++;
                }
            }
            UnityEngine.Debug.Assert(neighborCount >= m1, "Not enough neighbors of the correct type.", GM);
            placeable = placeable && (neighborCount >= m1);
        }
        placeable = placeable && (t._building is null) && (Building.TileOptions.ContainsKey(bt)) && (Building.TileOptions[bt].Contains(t._type)) && (GM._resourcesInWarehouse[GameManager.ResourceTypes.Planks] >= Building.cost_plank[bt]) && (GM._money >= Building.cost_money[bt]);
        return(placeable);
    }
Exemple #6
0
    /// <summary>
    /// Function that can change the type of the tile and replace its self in the grid array
    /// </summary>
    /// <param name="newType">New Type to switch to</param>
    /// <param name="originalTile">The Tile to switch from</param>
    /// <returns>Reference to the new Tile</returns>
    public static BaseTile ChangeTo(Tile.TileTypes newType, BaseTile originalTile)
    {
        BaseTile newTile = null;

        switch (newType)
        {
        case TileTypes.Tile:
            newTile = originalTile.gameObject.AddComponent <Tile>();
            break;

        case TileTypes.Satalite:
            newTile = originalTile.gameObject.AddComponent <Satellite>();
            break;

        case TileTypes.CombineSatellite:
            newTile = originalTile.gameObject.AddComponent <CombineSatellite>();
            break;

        case TileTypes.LightOutput:
            newTile = originalTile.gameObject.AddComponent <LightOutput>();
            break;

        case TileTypes.LightTarget:
            newTile = originalTile.gameObject.AddComponent <TargetTile>();
            break;

        case TileTypes.Asteroid:
            newTile = originalTile.gameObject.AddComponent <AsteroidTile>();
            break;

        case TileTypes.LightTrigger:
            newTile = originalTile.gameObject.AddComponent <LightTrigger>();
            break;

        case TileTypes.LightGate:
            newTile = originalTile.gameObject.AddComponent <LightGate>();
            break;

        case TileTypes.SatelliteSplitter:
            newTile = originalTile.gameObject.AddComponent <SplitterSatellite>();
            break;

        case TileTypes.LightFilter:
            newTile = originalTile.gameObject.AddComponent <FilterTile>();
            break;
        }

        if (newTile == null)
        {
            //report an Error and Back out
            Debug.LogError("Could not Change Tile target");
            return(null);
        }
        originalTile.RemoveTile();
        newTile.AssignNewTile(originalTile.arrayPosition, originalTile.creator, Color.black); //Tile will sort its self out

        DestroyImmediate(originalTile);
        return(newTile);
    }
Exemple #7
0
    private List <Tile> FindScalingNeighbors(Tile.TileTypes requireTileType, List <Tile> neighbors)
    {
        List <Tile> result = new List <Tile>();

        foreach (Tile tile in neighbors)
        {
            if (tile._type == requireTileType)
            {
                result.Add(tile);
            }
        }

        return(result);
    }
Exemple #8
0
 public void UpdateTurf()
 {
     Tile.TileTypes new_turfDescriptor = gameObject.GetComponent <Tile>().TileDescriptor;
     if (new_turfDescriptor != turfDescriptor)
     {
         turfDescriptor = new_turfDescriptor;
         BuildTurf();
     }
     else
     {
         UpdateUpper();
         UpdateLower();
     }
 }
Exemple #9
0
        private void OnGUI()
        {
            buildMode      = EditorGUILayout.Toggle("Enable Editor:", buildMode);
            editorFunction = (EditorFunction)EditorGUILayout.EnumPopup("Editor Function:", editorFunction);
            deleteMode     = EditorGUILayout.Toggle("Delete?:", deleteMode);
            y_select       = EditorGUILayout.IntField("Y-Level: ", y_select);
            DrawUILine(Color.gray);
            switch (editorFunction)
            {
            case (EditorFunction.add_tiles):
                selectedTileType = (Tile.TileTypes)EditorGUILayout.EnumPopup("TileType:", selectedTileType);
                upperTurfStat    = EditorGUILayout.IntField("Upper Turf Status:", upperTurfStat);
                lowerTurfStat    = EditorGUILayout.IntField("Lower Turf Status:", lowerTurfStat);
                break;

            case (EditorFunction.build_furniture):
                buildOrientation = EditorGUILayout.IntField("Orientation:", buildOrientation);
                LoadFurnitureTypes();
                LoadPrefabFurniture(furnitureTypes[furnitureTypes_index]);
                //buildTarget = EditorGUILayout.ObjectField("Build Target: ", buildTarget, typeof(GameObject), false) as GameObject;
                break;

            case (EditorFunction.build_disposal):
                //buildTarget = EditorGUILayout.ObjectField("Build Target: ", buildTarget, typeof(GameObject), false) as GameObject;
                pipeConnectN    = EditorGUILayout.Toggle("Connect N:", pipeConnectN);
                pipeConnectE    = EditorGUILayout.Toggle("Connect E:", pipeConnectE);
                pipeConnectS    = EditorGUILayout.Toggle("Connect S:", pipeConnectS);
                pipeConnectW    = EditorGUILayout.Toggle("Connect W:", pipeConnectW);
                pipeConnectAuto = EditorGUILayout.Toggle("Auto Connect:", pipeConnectAuto);
                break;

            case (EditorFunction.build_blue):
                //buildTarget = EditorGUILayout.ObjectField("Build Target: ", buildTarget, typeof(GameObject), false) as GameObject;
                pipeConnectN    = EditorGUILayout.Toggle("Connect N:", pipeConnectN);
                pipeConnectE    = EditorGUILayout.Toggle("Connect E:", pipeConnectE);
                pipeConnectS    = EditorGUILayout.Toggle("Connect S:", pipeConnectS);
                pipeConnectW    = EditorGUILayout.Toggle("Connect W:", pipeConnectW);
                pipeConnectAuto = EditorGUILayout.Toggle("Auto Connect:", pipeConnectAuto);
                break;

            case (EditorFunction.build_red):
                //buildTarget = EditorGUILayout.ObjectField("Build Target: ", buildTarget, typeof(GameObject), false) as GameObject;
                pipeConnectN    = EditorGUILayout.Toggle("Connect N:", pipeConnectN);
                pipeConnectE    = EditorGUILayout.Toggle("Connect E:", pipeConnectE);
                pipeConnectS    = EditorGUILayout.Toggle("Connect S:", pipeConnectS);
                pipeConnectW    = EditorGUILayout.Toggle("Connect W:", pipeConnectW);
                pipeConnectAuto = EditorGUILayout.Toggle("Auto Connect:", pipeConnectAuto);
                break;
            }
        }
        private void PropertiesWindow(int id)
        {
            EditorGUILayout.BeginVertical();
            // Show tile properties if any tile is selected
            if (selectedTileId >= 0)
            {
                Tile selectedTile = tilemap.Tiles[selectedTileId];

                EditorGUI.BeginChangeCheck();
                Tile.TileTypes type = (Tile.TileTypes)EditorGUILayout.EnumPopup("Tile Type:", selectedTile.TileType);
                if (EditorGUI.EndChangeCheck() && type != selectedTile.TileType)
                {
                    // Change underlying tile's type only when change really happened instead of changing it every frame
                    // Otherwise, all components' values will be constantly reset because of Tile's set TileTypes method
                    selectedTile.TileType = type;
                    AddComponentsToTile(selectedTile);
                }

                switch (selectedTile.TileType)
                {
                case Tile.TileTypes.Destructible:
                case Tile.TileTypes.Enemy:
                case Tile.TileTypes.Player:
                    Destructible destructible = selectedTile.FindComponent <Destructible>();
                    destructible.Lives = EditorGUILayout.IntSlider("Health", destructible.Lives, 1, 5);
                    break;

                case Tile.TileTypes.Item:
                    Item item = selectedTile.FindComponent <Item>();
                    item.RestoreHealthBy = EditorGUILayout.IntSlider("Restore Health by", item.RestoreHealthBy, 0, 5);
                    item.IncreaseBombsBy = EditorGUILayout.IntSlider("Increase # of bombs by", item.IncreaseBombsBy, 0, 3);
                    break;

                default:
                    break;
                }

                if (spritesheet != null)
                {
                    EditorGUILayout.LabelField("Sprite");
                    //Draw sprite
                    selectedTile.SpriteId = EditorGUILayout.IntSlider(selectedTile.SpriteId, 0, tilemap.Sprites.Count - 1);
                    GUI.DrawTextureWithTexCoords(new Rect(10, 150, 64, 64), spritesheet, tilemap.Sprites[selectedTile.SpriteId].DrawArea);
                }
                EditorGUILayout.EndVertical();
            }
        }
    // TODO: I am not sure how to compute efficiency. Here is my understanding:
    // Efficiency is the average of
    // - surrounding tiles
    // - number of employees
    // - happiness of employees
    float ComputeEfficiency()
    {
        float result = 1f;

        // compute efficiency based on surrounding tiles
        if (this._scalesWithNeighboringTiles)
        {
            Tile.TileTypes tt = Tile.TileTypes.Empty;
            switch (this._type)
            {
            case BuildingType.Fishery:
                tt = Tile.TileTypes.Water;
                break;

            case BuildingType.Lumberjack:
                tt = Tile.TileTypes.Forest;
                break;

            case BuildingType.SheepFarm:
            case BuildingType.PotatoFarm:
                tt = Tile.TileTypes.Grass;
                break;
            }
            int surroundingTiles = this._tile._neighbourTiles.FindAll(t => t._type == tt).Count;
            if (this._maxNeighbors <= surroundingTiles)
            {
                result = 1f;
            }
            if (this._minNeighbors > surroundingTiles)
            {
                result = 0f;
            }
            result = (float)surroundingTiles / this._maxNeighbors;
        }

        // add effiency based on the precentage of employment
        result += (float)_workers.Count / this._jobsCapacity;
        // add effiency based on happiness of workers
        if (_workers.Count > 0)
        {
            result += (float)_workers.Sum(w => w._happiness) / _workers.Count;
        }

        Debug.Log("Efficiency: " + result);
        return((float)result * 1 / 3);
    }
Exemple #12
0
    // Update is called once per frame
    void Update()
    {
        SetMousePosition();
        AdjustClock();

        if (curMode == Mode.Run)
        {
            if (Input.GetButtonDown("Fire1") && !EventSystem.current.IsPointerOverGameObject())
            {
                Debug.Log(mouseOverTile.GetTileType());
                Tile.TileTypes tType = mouseOverTile.GetTileType();
                if (tType == Tile.TileTypes.Building)
                {
                    ui.SetBuildingSelector(mouseOverTile as BuildableTile);
                }
                else if (tType == Tile.TileTypes.BuildingChild)
                {
                    ui.SetBuildingSelector(((BuildableTileChild)mouseOverTile).GetParent());
                }
                else
                {
                    ui.HideBuildingSelector();
                }
            }
        }
        else if (curMode == Mode.Build)
        {
            buildMode.Build(mouseOverTile);
            if (Input.GetButtonDown("Fire1") && !EventSystem.current.IsPointerOverGameObject())
            {
                buildMode.AttemptToBuild();
            }
        }

        if (Input.GetKeyDown(KeyCode.Escape))
        {
            StartRunMode();
            ui.HideBuildMenu();
            ui.HideBuildingSelector();
        }
    }
Exemple #13
0
    public Tile ParseTileData(string spriteName)
    {
        //Default type
        Tile.TileTypes newType = Tile.TileTypes.HEALTH;

        string[] split = spriteName.Split('_');


        string type      = split[0];
        int    tileValue = Convert.ToInt32(split[1]);

        switch (type.ToLower())
        {
        case "health":
            newType = Tile.TileTypes.HEALTH;
            break;

        case "money":
            newType = Tile.TileTypes.MONEY;
            break;

        case "social":
            newType = Tile.TileTypes.SOCIAL;
            break;

        case "time":
            newType = Tile.TileTypes.TIME;
            break;

        default:
            break;
        }
        Tile newTile = new Tile(newType, tileValue);

        newTileToSwap = newTile;
        return(newTile);
    }
Exemple #14
0
    private void ValidateCard(Tile.TileTypes type, int amount)
    {
        switch (type)
        {
        case Tile.TileTypes.SOCIAL:
            if (PlayerInventory.Social < amount)
            {
                this.enabled = false;
            }
            break;

        case Tile.TileTypes.HEALTH:
            if (PlayerInventory.Health < amount)
            {
                this.enabled = false;
            }
            break;

        case Tile.TileTypes.MONEY:
            if (PlayerInventory.Money < amount)
            {
                this.enabled = false;
            }
            break;

        case Tile.TileTypes.TIME:
            if (PlayerInventory.Time < amount)
            {
                this.enabled = false;
            }
            break;

        default:
            break;
        }
    }
Exemple #15
0
 void ChangeTo(Tile.TileTypes newType)
 {
     BaseTile.ChangeTo(newType, (BaseTile)target);
 }
Exemple #16
0
    public static void GetResources(Tile.TileTypes Type, GameObject MapStart, out GameObject ATile)
    {
        ATile = Instantiate(Tools.FindPfbPerName("tile_pfb"), MapStart.transform) as GameObject;
        ATile.SetActive(false);
        Sprite spr;

        switch (Type)
        {
        case Tile.TileTypes.TILE_START:     // start
            spr = Tools.FindSpritePerName("tile_start");
            break;

        case Tile.TileTypes.TILE_BOMB:     // bomb
            spr = Tools.FindSpritePerName("tile_bomb");
            break;

        case Tile.TileTypes.TILE_DICE:     // dice
            spr = Tools.FindSpritePerName("tile_dice");
            break;

        case Tile.TileTypes.TILE_REWARD:     // reward
            spr = Tools.FindSpritePerName("tile_reward");
            break;

        case Tile.TileTypes.TILE_SWITCH:     // switch
            spr = Tools.FindSpritePerName("tile_switch");
            break;

        case Tile.TileTypes.TILE_CATCHCOINS:     // catchcoins
            spr = Tools.FindSpritePerName("tile_catchcoins");
            break;

        case Tile.TileTypes.TILE_GUESSBOX:     // guessbox
            spr = Tools.FindSpritePerName("tile_guessbox");
            break;

        case Tile.TileTypes.TILE_BOXREWARD_1:     // box1
            spr = Tools.FindSpritePerName("tile_boxreward_1");
            break;

        case Tile.TileTypes.TILE_BOXREWARD_2:     // box2
            spr = Tools.FindSpritePerName("tile_boxreward_2");
            break;

        case Tile.TileTypes.TILE_CUP:     // cup
            spr = Tools.FindSpritePerName("tile_cup");
            break;

        case Tile.TileTypes.TILE_BOSS:     // boss
            spr = Tools.FindSpritePerName("tile_boss");
            break;

        case Tile.TileTypes.TILE_APPLE:     // apple
            spr = Tools.FindSpritePerName("tile_apple");
            break;

        case Tile.TileTypes.TILE_BUG:     // bugs
            spr = Tools.FindSpritePerName("tile_bug");
            break;

        case Tile.TileTypes.TILE_FOOD:     // foods
            spr = Tools.FindSpritePerName("tile_food");
            break;

        case Tile.TileTypes.TILE_HISTORY:     // history
            spr = Tools.FindSpritePerName("tile_history");
            break;

        case Tile.TileTypes.TILE_HUMAN:     // human
            spr = Tools.FindSpritePerName("tile_human");
            break;

        default:
            spr = Tools.FindSpritePerName("tile_dice");
            break;
        }
        Tools.SetObjAndSprSameSize(ATile, spr);
        ATile.GetComponent <Image>().sprite = spr;
    }
Exemple #17
0
 public CreatureGeneModifier(Tile.TileTypes tileType, CreatureStatType statType, float modValue)
 {
     this.tileType      = tileType;
     this.statType      = statType;
     this.modifierValue = modValue;
 }
Exemple #18
0
 /// <summary>
 /// Call this to put a message back to its default state.
 /// </summary>
 public override void Reset()
 {
     mPosition_In = Vector2.Zero;
     mType_In = Tile.TileTypes.Empty;
     mPreviousType_Out = Tile.TileTypes.Empty;
 }
Exemple #19
0
    public void DoEvent(Tile.TileTypes Type, GM inGM)
    {
        GameObject ca = GameObject.FindGameObjectWithTag("PopCanvas");

        switch (Type)
        {
        case Tile.TileTypes.TILE_START:     // start
            // 不会发生任何事情
            break;

        case Tile.TileTypes.TILE_BOMB:     // bomb
            GameObject ExplodePfb = Instantiate(Tools.FindPfbPerName("explode_pfb"), GameObject.FindGameObjectWithTag("mapcanvas").transform) as GameObject;
            ExplodePfb.transform.position = inGM.Niko.Position.TilePfb.transform.position;
            ExplodePfb.SetActive(true);
            ExplodePfb.transform.DOLocalMoveY(ExplodePfb.transform.localPosition.y + 100, 1).OnComplete(() => {
                GameObject.Destroy(ExplodePfb);
            });
            // StartCoroutine(PlayAnimation());
            inGM.PlayerGoBack();
            break;

        case Tile.TileTypes.TILE_DICE:     // dice
            inGM.PlayerGoForward(UnityEngine.Random.Range(1, 4));
            break;

        case Tile.TileTypes.TILE_REWARD:     // reward
            GameObject CpinsPfb = Instantiate(Tools.FindPfbPerName("coins_pfb"), GameObject.FindGameObjectWithTag("mapcanvas").transform) as GameObject;
            CpinsPfb.transform.position = inGM.Niko.Position.TilePfb.transform.position;
            CpinsPfb.SetActive(true);
            CpinsPfb.transform.DOLocalMoveY(CpinsPfb.transform.localPosition.y + 100, 1).OnComplete(() => {
                GameObject.Destroy(CpinsPfb);
            });
            break;

        case Tile.TileTypes.TILE_SWITCH:     // switch
            break;

        case Tile.TileTypes.TILE_CATCHCOINS:     // catchcoins
            GameObject CollectGame = Instantiate(Tools.FindPfbPerName("collectgame_pfb"), ca.transform) as GameObject;
            CollectGame.GetComponent <CollectGameClick>().TM = this;
            CollectGame.SetActive(true);
            break;

        case Tile.TileTypes.TILE_GUESSBOX:     // guessbox

            GameObject GuessBox = Instantiate(Tools.FindPfbPerName("guessbox_pfb"), ca.transform) as GameObject;
            GuessBox.GetComponent <ChooseBoxClick>().TM = this;
            GuessBox.SetActive(true);
            break;

        case Tile.TileTypes.TILE_BOXREWARD_1:     // box1
        case Tile.TileTypes.TILE_BOXREWARD_2:     // box2
            ca.transform.Find("GetReward").gameObject.SetActive(true);
            break;

        case Tile.TileTypes.TILE_CUP:     // cup

            break;

        case Tile.TileTypes.TILE_BOSS:    // boss
        case Tile.TileTypes.TILE_APPLE:   // apple
        case Tile.TileTypes.TILE_BUG:     // bugs
        case Tile.TileTypes.TILE_FOOD:    // foods
        case Tile.TileTypes.TILE_HISTORY: // history
        case Tile.TileTypes.TILE_HUMAN:   // human
            GameObject WordGame = Instantiate(Tools.FindPfbPerName("wordgame_pfb"), ca.transform) as GameObject;
            WordGame.GetComponent <WordGameClick>().TM   = this;
            WordGame.GetComponent <WordGameClick>().inGM = inGM;
            WordGame.SetActive(true);
            break;

        default:
            break;
        }

        inGM.ResetDice();
        if (Type != Tile.TileTypes.TILE_BOMB)
        {
            inGM.LocateCamera();
        }
    }
Exemple #20
0
 public void SetTile(Tile.TileTypes tileType)
 {
     this.n_TileType = (byte)tileType;
     // set dirtyBit Trigger 001<Tile>  010<Turf> 100<Pipe>
     SetDirtyBit(base.syncVarDirtyBits ^ 0b001);
 }