private void bombAnim(object obj)
        {
            if (state == BombState.alive)
            {
                flipSprite();

                // local data for my call back (I call it monkey)
                CallBackData monoData = (CallBackData)obj;
                // get the current time
                TimeSpan totTime = Timer.GetCurrentTime() - monoData.deltaTime;

                if (totTime.TotalSeconds > 5)
                {
                    BombManager.Instance().removeBomb(this);
                }
                else
                {
                    // Update my target time for next TimeEvent
                    monoData.targetTime = Timer.GetCurrentTime() + new TimeSpan(0, 0, 0, 0, 300);
                    // just increment count to show off
                    monoData.count += 10;
                    // install next TimeEvent
                    Timer.Add(monoData.targetTime, obj, bombAnim);
                }
            }
            else
            {
            }
        }
        private void createBomb(PlayerID _id, Ship s)
        {
            BombData data = BombManager.Instance().getNextBomb(_id);

            bombID = data.ID;

            bombsprite = data.sprite;
            spriteRef  = new Sprite_Proxy(bombsprite, (int)s.spriteRef.pos.X, (int)s.spriteRef.pos.Y, 0.5f, Color.White);

            SBNode bombBatch = SpriteBatchManager.Instance().getBatch(batchEnum.bomb);

            bombBatch.addDisplayObject(spriteRef);

            orgPos = spriteRef.pos;


            if (_id == PlayerID.one)
            {
                image1 = ImageManager.Instance().getImage(ImageEnum.bluebomb1);
                image2 = ImageManager.Instance().getImage(ImageEnum.bluebomb2);
            }
            else
            {
                image1 = ImageManager.Instance().getImage(ImageEnum.greenbomb1);
                image2 = ImageManager.Instance().getImage(ImageEnum.greenbomb2);
            }

            spriteRef.sprite.image = image1;

            curImage = 0;

            state = BombState.alive;
        }
 public MainWindow()
 {
     InitializeComponent();
     DefaultModel = new MasterPageModel(this);
     Manager      = new PageManager(this);
     Bomb         = new BombManager();
 }
Esempio n. 4
0
    // Use this for initialization
    void Start()
    {
        currentReplayStep = new ReplayReader.ReplayStep();

        alreadyGenerateStatistic = false;
        matchResults             = new List <uint>();

        grid       = gameObject.GetComponent <Grid>();
        scenarioId = grid.scenarioId;
        academy    = FindObjectOfType(typeof(BombermanAcademy)) as BombermanAcademy;

        playerManager = ServiceLocator.getManager(scenarioId).GetPlayerManager();
        bombManager   = ServiceLocator.getManager(scenarioId).GetBombManager();
        blocksManager = ServiceLocator.getManager(scenarioId).GetBlocksManager();

        playerManager.initInitialPositions(grid);

        ServiceLocator.getManager(scenarioId).GetLogManager().episodePrint(playerManager.getEpisodeCount());

        playerManager.setRandomizeIterationOfAgents(randomizeIterationOfAgents);

        //Vector3 monitorPosition = transform.position + new Vector3(-3, 4, 1); // scene sem imitação
        Vector3 monitorPosition = transform.position + new Vector3(-6.72f, 4, -4.51f);

        myMonitor = Instantiate(monitorPrefab, monitorPosition, Quaternion.identity, transform.parent);
        Monitor.Log("Last Result:", "draw", myMonitor.transform);
        Monitor.Log("Iteration:", "0 / " + maxIterationString, myMonitor.transform);
        Monitor.Log("Episode:", "1", myMonitor.transform);
        Monitor.Log("Scenario:", transform.parent.gameObject.name, myMonitor.transform);

        iterationWhereWasCreatedBombs = 0;
        numberOfBombsByCreation       = 1;

        // replay
        if (saveReplay)
        {
            replayWriter = new ReplayWriter(scenarioId);
        }

        if (followReplayFile)
        {
            replayReader = new ReplayReader(replayFileName);
            ReplayReader.ReplayStep rStep = replayReader.readStep(ReplayCommandLine.RCL_Episode);
            if (rStep.command == ReplayCommandLine.RCL_Episode)
            {
                currentReplayStep.epId = rStep.epId;
            }
            else
            {
                Debug.Log("Nao e pra entrar aqui. Leitura de episódio errada");
            }
        }

        //Debug.Log("Criando MapController");
        createAgents();
        initBlocks();

        wasInitialized = true;
        reseting       = false;
    }
Esempio n. 5
0
        private void reactionToShip(Ship s, Bomb b, Vector2 _point)
        {
            if (s.type == GameObjType.p1ship)
            {
                GameObjManager.Instance().remove(batchEnum.ships, s);
                BombManager.Instance().removeBomb(b, s.spriteRef.pos, s.spriteRef.color);

                hit(PlayerID.one);

                ScoreManager.Instance().p2Kill();

                playShipHitSound();
                playBombHitSound();
            }

            else if (s.type == GameObjType.p2ship)
            {
                GameObjManager.Instance().remove(batchEnum.ships, s);
                BombManager.Instance().removeBomb(b, s.spriteRef.pos, s.spriteRef.color);

                hit(PlayerID.two);

                ScoreManager.Instance().p1Kill();

                playShipHitSound();
                playBombHitSound();
            }
            else
            {
            }

            playShipHitSound();
        }
Esempio n. 6
0
    protected override void OnStart()
    {
        base.OnStart();
        bombManager = GetComponent <BombManager>();
        if (transform.root.gameObject.name.Contains("Balloom"))
        {
            enemy = new Balloom(transform.root.gameObject);
        }
        else if (transform.root.gameObject.name.Contains("Oneal"))
        {
            enemy = new Oneal(transform.root.gameObject);
        }
        playerPosition = GameObject.FindGameObjectWithTag("Player").transform.position;
        path           = new List <Vector3>();

        if (enemy.intelligence == Smart.Low)
        {
            intelligentSystem = new IntelligentSystemBase(enemy);
        }
        else if (enemy.intelligence == Smart.High)
        {
            intelligentSystem = new AdvancedIntelligentSystem(enemy);
        }
        audioSource = GetComponentInChildren <AudioSource>();
    }
Esempio n. 7
0
 void OnMouseUpAsButton()
 {
     if (BombManager._instance.count > 0)
     {
         Enemy       toDie    = GameObject.FindObjectOfType <Enemy>();
         BombManager UseABomb = GameObject.FindObjectOfType <BombManager>();
     }
 }
Esempio n. 8
0
 void Start()
 {
     player      = new Player(GameObject.FindGameObjectWithTag("Player"));
     bombManager = GetComponent <BombManager>();
     audioSource = GetComponentInChildren <AudioSource>();
     base.OnStart();
     animator = player.gameObject.GetComponent <Animator>();
 }
Esempio n. 9
0
 public Managers(int _id)
 {
     id              = _id;
     sLogManager     = new LogManager(id);
     sBombManager    = new BombManager();
     sBlocksManager  = new BlocksManager();
     myPlayerManager = new PlayerManager();
 }
Esempio n. 10
0
    void Awake()
    {
        Instance = this;

        mClient = LobbyManager.s_Singleton.client;

        //NetworkServer.RegisterHandler(MSG_TYPE, OnServerPostChatMessage);
    }
Esempio n. 11
0
 // Start is called before the first frame update
 public override void OnInitialize()
 {
     base.OnInitialize();
     mapManager   = new MapManager(gameGridMap, destructableTile, explosion);
     bombManager  = new BombManager(bomb, mapManager);
     enemyManager = new EnemyManager(enemyPrefab, mapManager);
     uiManager    = new UIManager(gameUIController, popUp, playButon, joyStick, fireBomb);
 }
        private void reactionToBomb(Missile m, Bomb b, Vector2 _point)
        {
            BombManager.Instance().removeBomb(b, b.spriteRef.pos, b.spriteRef.color);

            GameObjManager.Instance().remove(batchEnum.missiles, m);

            PlayerManager.getPlayer(m.owner).increaseNumMissiles();
        }
Esempio n. 13
0
 void Awake()
 {
     mSingleton = this;
     //
     foreach (GameObject b in BombPrefabs)
     {
         b.SetActive(false);
     }
 }
Esempio n. 14
0
    void BombDestroySequence()
    {
        BombManager bombManager = _binBomb.GetComponent <BombManager>();

        bombManager.Bomb_OnClick();

        _empty = true;
        EventBus.BinCleared.Dispatch(gameObject);
    }
Esempio n. 15
0
    public static BombManager GetInstance()
    {
        if(instance == null)
        {
            instance = new BombManager();
            instance.Init();
        }

        return instance;
    }
Esempio n. 16
0
        public static void SolveButton(BombManager bombData, ref ButtonModule moduleData)
        {
            if (moduleData.Strip == ButtonColor.Disabled)
            {
                if (moduleData.Color == ButtonColor.Blue && moduleData.Text == ButtonText.Abort)
                {
                    moduleData.SetSolution(ButtonPhase.HoldAwait);
                }
                else if (bombData.Batteries > 1 && moduleData.Text == ButtonText.Detonate)
                {
                    moduleData.SetSolution(ButtonPhase.ReleaseImmediately);
                    moduleData.RaiseDependencyFlag(DependencyFlag.Batteries);
                }
                else if (bombData.IsIndicatorLit(Indicators.CAR) && moduleData.Color == ButtonColor.White)
                {
                    moduleData.SetSolution(ButtonPhase.HoldAwait);
                    moduleData.RaiseDependencyFlag(DependencyFlag.IndicatorCAR);
                }
                else if (bombData.Batteries > 2 && bombData.IsIndicatorLit(Indicators.FRK))
                {
                    moduleData.SetSolution(ButtonPhase.ReleaseImmediately);
                    moduleData.RaiseDependencyFlag(DependencyFlag.Batteries);
                    moduleData.RaiseDependencyFlag(DependencyFlag.IndicatorFRK);
                }
                else if (moduleData.Color == ButtonColor.Yellow)
                {
                    moduleData.SetSolution(ButtonPhase.HoldAwait);
                }
                else if (moduleData.Color == ButtonColor.Red && moduleData.Text == ButtonText.Hold)
                {
                    moduleData.SetSolution(ButtonPhase.ReleaseImmediately);
                }
                else
                {
                    moduleData.SetSolution(ButtonPhase.HoldAwait);
                }
            }
            else
            {
                switch (moduleData.Strip)
                {
                case ButtonColor.Blue:
                    moduleData.SetSolution(ButtonPhase.ReleaseFour);
                    break;

                case ButtonColor.Yellow:
                    moduleData.SetSolution(ButtonPhase.ReleaseFive);
                    break;

                default:
                    moduleData.SetSolution(ButtonPhase.ReleaseOne);
                    break;
                }
            }
        }
Esempio n. 17
0
    void AddDie()
    {
        BombManager.GetInstance().CreateBomb(BombType.BombType_1, this.transform.position);

        if (MusicManager.GetInstance().SFXCtrl != null)
        {
            MusicManager.GetInstance().SFXCtrl.PlaySound(SoundType.Sound_EnemyBomb);
        }

        Destroy(this.gameObject);
    }
Esempio n. 18
0
        private static void InitializeWithScene()
        {
            PlayerRenderer = CommonUtils.GetComponentInGameObjectFoundWithTagOrPanic <MeshInstanceRendererComponent>(
                BombariaTags.PLAYER,
                CommonUtils.GetComponentPostCommand.DestroyGameObject)
                             .Value;

            BombManager = BombManager.GetInstance();

            NewGame();
        }
Esempio n. 19
0
 private void Awake()
 {
     if (m_bombManager == null)
     {
         m_bombManager = this;
     }
     else if (m_bombManager != this)
     {
         Destroy(gameObject);
     }
 }
Esempio n. 20
0
 void Awake()
 {
     if (instance)
     {
         Destroy(this.gameObject);
     }
     else
     {
         instance = this;
     }
 }
Esempio n. 21
0
 void Awake()
 {
     if (_sSingleton != null && _sSingleton != this)
     {
         Destroy(this.gameObject);
     }
     else
     {
         _sSingleton = this;
     }
 }
Esempio n. 22
0
 /// <summary>
 /// Permet de récupérer l'instance du singleton
 /// </summary>
 /// <returns></returns>
 public static BombManager GetBombManagerInstance()
 {
     if (_instance == null) {
         lock (instanceLock) {
             if (_instance == null) {
                 //on vérifie encore, au cas où l'instance aurait été créée entretemps.
                 _instance = new BombManager();
             }
         }
     }
     return _instance;
 }
Esempio n. 23
0
        public static void SolveSimonSays(BombManager bombData, ref SimonSaysModule moduleData)
        {
            int len = moduleData.FlashSequence.Length;

            SimonColors[] returnSequence = new SimonColors[len];
            for (int i = 0; i < len; i++)
            {
                returnSequence[i] = GetSimonColor(moduleData.FlashSequence[i], bombData.Strikes, bombData.SerialContainsVowel());
            }
            moduleData.SetSolution(returnSequence);
            moduleData.RaiseDependencyFlag(DependencyFlag.SerialNumber);
            moduleData.RaiseDependencyFlag(DependencyFlag.Strikes);
        }
Esempio n. 24
0
 void Start()
 {
     source      = GetComponent <AudioSource>();
     bombManager = GetComponent <BombManager>();
     GameObject[] MachinesGo = GameObject.FindGameObjectsWithTag("Machine");
     machineArray = new Machine[MachinesGo.Length];
     for (int i = 0; i < MachinesGo.Length; i++)
     {
         machineArray[i] = MachinesGo[i].GetComponent <Machine>();
     }
     bombManager.bombingCD = bombManager.maxBombingTime;
     StartCoroutine(SpawnTentacouille());
 }
Esempio n. 25
0
    protected override void HitPlayer(Collision other)
    {
        PlayersGameplay playerScript = null;

        if (other.gameObject.tag == "Player")
        {
            playerScript = other.gameObject.GetComponent <PlayersGameplay> ();
        }

        if (tag == "Movable" && other.gameObject.tag == "Player" ||
            tag == "ThrownMovable" && other.gameObject.tag == "Player" && !trackingPlayer)
        {
            if (playerThatThrew == null || playerThatThrew != other.gameObject)
            {
                if (!trackingPlayer && playerThatThrew != null)
                {
                    StatsManager.Instance.PlayersHits(playerThatThrew, other.gameObject);
                }

                BombManager manager = (BombManager)GlobalVariables.Instance.lastManManager;

                if (manager.timer < 1 && !trackingPlayer && playerThatThrew != null)
                {
                    SteamAchievements.Instance.UnlockAchievement(AchievementID.ACH_BOMB);
                }

                playerScript.OnHoldMovable(gameObject, true);
                playerHolding = other.gameObject;

                mainCamera.GetComponent <ScreenShakeCamera>().CameraShaking(FeedbackType.Stun);
                mainCamera.GetComponent <ZoomCamera>().Zoom(FeedbackType.Stun);

                InstantiateParticles(other.contacts [0], GlobalVariables.Instance.HitParticles, GlobalVariables.Instance.playersColors [(int)playerScript.playerName]);
            }
        }

        if (tag == "DeadCube" && other.gameObject.tag == "Player" && trackingPlayer && playerScript.playerState != PlayerState.Dead)
        {
            hold          = true;
            playerHolding = other.gameObject;

            playerScript.OnDeath -= PlayerSuicide;
            playerScript.Death(DeathFX.All, other.contacts [0].point);

            mainCamera.GetComponent <ScreenShakeCamera>().CameraShaking(FeedbackType.Stun);
            mainCamera.GetComponent <ZoomCamera>().Zoom(FeedbackType.Stun);

            InstantiateParticles(other.contacts [0], GlobalVariables.Instance.HitParticles, GlobalVariables.Instance.playersColors [(int)playerScript.playerName]);
        }
    }
Esempio n. 26
0
 protected override void OnActivate()
 {
     try
     {
         Core.Init.Prepare();
         Core.Config._Menu = new Core.Menus.Menu();
         this._Context.MenuManager.RegisterMenu((object)Core.Config._Menu);
         this._Input.MouseClick       += new EventHandler <MouseEventArgs>(MouseRegionCatch.Input_MouseClick);
         Core.Config._Renderer.Draw   += new EventHandler(Drawings.BombStack.OnDraw);
         Core.Config._Renderer.Draw   += new EventHandler(Drawings.LandStack.OnDraw);
         Core.Config._Renderer.Draw   += new EventHandler(LandTimer.OnDraw);
         Core.Config._Renderer.Draw   += new EventHandler(Info.OnDraw);
         Core.Config._Renderer.Draw   += new EventHandler(Hello.OnDraw);
         ObjectManager.OnAddEntity    += new ObjectManagerAddEntity(BombManager.OnAddEntity);
         ObjectManager.OnRemoveEntity += new ObjectManagerRemoveEntity(BombManager.OnRemoveEntity);
         Entity.OnInt32PropertyChange += new EntityInt32PropertyChange(BombManager.OnInt32Change);
         UpdateManager.Subscribe(new Action(BombOnHitLogic.OnUpdate), 25, true);
         UpdateManager.Subscribe(new Action(LandRunKillLogic.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(CreepDetonationLogic.OnUpdate), 200, true);
         UpdateManager.Subscribe(new Action(ForceLogic.OnUpdate), 50, true);
         UpdateManager.Subscribe(new Action(BombOnHitLogic.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(ModWatcherLogic.OnUpdate), 50, true);
         UpdateManager.BeginInvoke(new Action(this.DetonationLoop), 0);
         UpdateManager.Subscribe(new Action(InvisibleDetonationLogic.OnUpdate), 50, true);
         UpdateManager.Subscribe(new Action(Drawings.BombStack.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(Drawings.LandStack.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(Bombs.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(Force.OnUpdate), 50, true);
         UpdateManager.Subscribe(new Action(EULCombo.OnUpdate), 100, true);
         UpdateManager.Subscribe(new Action(ParticleRemover.OnUpdate), 1000, true);
         UpdateManager.Subscribe(new Action(EnemyUpdater.OnUpdate), 5000, true);
         Core.Config._EULComboTask = new TaskHandler(new Func <CancellationToken, Task>(EULComboLogic.OnUpdateTask), true);
         this._InventoryManager.Attach((object)Core.Config._Items);
         Entity.OnAnimationChanged += new EntityAnimationChanged(TechiesRage.OnAnimationChanged);
         BombManager.Update();
         Task.Run((Func <Task>)(async() =>
         {
             await Task.Delay(15000);
             Core.Config._Hello = false;
         }));
         Core.Config.Log.Warn("Load completed");
         Printer.Print("Please read docs for Techies Rage at RageScript.pro", false);
         Printer.Print("And check your detonation mode in menu/features", false);
     }
     catch (Exception ex)
     {
         Core.Config.Log.Error(ex.ToString());
     }
 }
Esempio n. 27
0
    void Update()
    {
        ThalmicMyo thalmicMyo = myo.GetComponent <ThalmicMyo>();

        if (thalmicMyo.pose != _lastPose)
        {
            _lastPose = thalmicMyo.pose;

            if (thalmicMyo.pose == Pose.FingersSpread && BombManager._instance.count > 0)
            {
                this.UseABomb();
                //GameObject.Find("bomb").GetComponent<Enemy>().toDie();
                Enemy       toDie    = GameObject.FindObjectOfType <Enemy>();
                BombManager UseABomb = GameObject.FindObjectOfType <BombManager>();
                ExtendUnlockAndNotifyUserAction(thalmicMyo);
            }
        }
    }
Esempio n. 28
0
        protected override void Start()
        {
            base.Start();

            cubeScript = GetComponent <MovableScript>();

            cubeMaterial = transform.GetChild(1).GetComponent <Renderer>().material;

            bombManager = FindObjectOfType <BombManager>();

            if (bombManager != null)
            {
                text = GetComponentInChildren <Text>();
            }

            cubeScript.OnNeutral += () => deadlyData.Add(new DeadlyData(false));
            cubeScript.OnDeadly  += () => deadlyData.Add(new DeadlyData(true));
        }
Esempio n. 29
0
        public static void InitNewStacker(this BombManager manager, BombManager ignreManager)
        {
            var closest =
                Core.Bombs.Where(
                    x =>
                    !x.Equals(ignreManager) && x.IsRemoteMine && x.Stacker.IsActive &&
                    x.BombPosition.Distance2D(manager.BombPosition) <= 200)
                .OrderBy(y => y.BombPosition.Distance2D(manager.BombPosition))
                .FirstOrDefault();

            if (closest != null)
            {
                closest.Stacker.Counter++;
            }
            else
            {
                manager.Stacker.Counter++;
            }
        }
Esempio n. 30
0
    //Função foi criada para inicializar atributos do agente após a instanciação. Porque ao usar a instanciação, automaticamente é chamado InitializeAgent e Start.
    public void init(Grid g, int pNumber)
    {
        //Debug.Log("Init foi chamado");
        grid           = g;
        scenarioId     = grid.scenarioId;
        playerNumber   = pNumber;
        stateType      = convertPlayerNumberToStateType(playerNumber);
        myGridViewType = grid.getGridViewType();

        bombCount            = 0;
        isInFire             = false;
        isInDanger           = false;
        areThereDangerAround = false;
        myDistanceRewardList = new List <PlayerManager.DistanceReward>();
        canDropBombs         = true;
        isReady = true;
        lastMan = false;

        localStep = 1;

        ServiceLocator.getManager(scenarioId).GetLogManager().localEpisodePrint(localEpisode++, this);

        //------------------------------------------------------ São atualizadas no Start, que é chamado depois
        initialPosition  = transform.localPosition;
        oldLocalPosition = transform.localPosition;
        oldGridPosition  = GetOldGridPosition();
        // -----------------------------------------------------------------------------------------------------

        playerModel = transform.Find("PlayerModel").gameObject;
        animator    = transform.Find("PlayerModel").GetComponent <Animator>();

        bombermanVillain.Clear();

        actionIdString = "empty";

        wasInitialized = true;

        myPlayerManager = ServiceLocator.getManager(scenarioId).GetPlayerManager();
        myBombManager   = ServiceLocator.getManager(scenarioId).GetBombManager();
    }
Esempio n. 31
0
    void Update()
    {
        if (!CanFly)
        {
            return;
        }
        Vector2 dir = new Vector2(1.0f, 0.0f);

        dir.Normalize();
        transform.localPosition = transform.localPosition + (new Vector3(dir.x, 0, 0) * Speed * Time.deltaTime);

        if (transform.localPosition.x >= 0.0f)
        {
            BombManager.GetInstance().CreateBomb(BombType.BombType_PlayerBomb, new Vector2(this.transform.position.x, this.transform.position.y));
            if (MusicManager.GetInstance().SFXCtrl != null)
            {
                MusicManager.GetInstance().SFXCtrl.PlaySound(SoundType.Sound_BigBomb);
            }
            Destroy(this.gameObject);
        }
        //
    }
 void Start()
 {
     player      = new Player();
     bombManager = GetComponent <BombManager>();
     base.OnStart();
 }
Esempio n. 33
0
    // Use this for initialization
    void Start()
    {
        // Retrieve bomb manager instance
        _BombManager = BombManager.GetBombManagerInstance();
        // Retrieve the bomb ticking animation and launch it
        bombTickingAnimation = this.GetComponent<Animation>();

        // Retrieve the bom transform property
        bombTransform = this.GetComponent<Transform>();

        // Retrieve the explosion sound and store it
        bombExplosionSound = this.GetComponent<AudioSource>();

        // Retrieve the Particle System and store it
        bombExplosionParticle = this.GetComponent<ParticleSystem>();

        TailleExplosion.Set(tailleExplosion, tailleExplosion, tailleExplosion);

        SphereCollider[] listeSphereCollider = this.GetComponentsInChildren<SphereCollider>();
        for(int i = 0; i< listeSphereCollider.Length; i++) {
            if (listeSphereCollider[i].gameObject.layer == LayerMask.NameToLayer("Explosion")) {
                bombExplosionTrigger = (SphereCollider)listeSphereCollider[i];
                bombExplosionTrigger.isTrigger = false;
                bombExplosionTrigger.enabled = false;

                bombExplosionTrigger.GetComponent<SphereCollider>().radius = (0.11111f * tailleExplosion);
                break;
            }

        }

        Transform[] listeMesh = this.GetComponentsInChildren<Transform>();

        for(int i = 0; i< listeMesh.Length; i++) {
            if (listeMesh[i].gameObject.layer == LayerMask.NameToLayer("ExplosionGraphic")) {
                bomGraphic = ((Transform)listeMesh[i]);
                bomGraphic.transform.localScale = TailleExplosion;
                //bombGraphicMesh.enabled = false;
                break;
            }
        }

        bombExplosion = this.GetComponentInChildren<ToggleExplosion>();
        bombExplosion.Hide();
        _BombManager.AddBomb(this.gameObject);
    }
Esempio n. 34
0
 void OnDestroy()
 {
     Instance = null;
 }