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();
}
// 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;
}
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();
}
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>();
}
void OnMouseUpAsButton()
{
if (BombManager._instance.count > 0)
{
Enemy toDie = GameObject.FindObjectOfType <Enemy>();
BombManager UseABomb = GameObject.FindObjectOfType <BombManager>();
}
}
void Start()
{
player = new Player(GameObject.FindGameObjectWithTag("Player"));
bombManager = GetComponent <BombManager>();
audioSource = GetComponentInChildren <AudioSource>();
base.OnStart();
animator = player.gameObject.GetComponent <Animator>();
}
public Managers(int _id)
{
id = _id;
sLogManager = new LogManager(id);
sBombManager = new BombManager();
sBlocksManager = new BlocksManager();
myPlayerManager = new PlayerManager();
}
void Awake()
{
Instance = this;
mClient = LobbyManager.s_Singleton.client;
//NetworkServer.RegisterHandler(MSG_TYPE, OnServerPostChatMessage);
}
// 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();
}
void Awake()
{
mSingleton = this;
//
foreach (GameObject b in BombPrefabs)
{
b.SetActive(false);
}
}
void BombDestroySequence()
{
BombManager bombManager = _binBomb.GetComponent <BombManager>();
bombManager.Bomb_OnClick();
_empty = true;
EventBus.BinCleared.Dispatch(gameObject);
}
public static BombManager GetInstance()
{
if(instance == null)
{
instance = new BombManager();
instance.Init();
}
return instance;
}
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;
}
}
}
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);
}
private static void InitializeWithScene()
{
PlayerRenderer = CommonUtils.GetComponentInGameObjectFoundWithTagOrPanic <MeshInstanceRendererComponent>(
BombariaTags.PLAYER,
CommonUtils.GetComponentPostCommand.DestroyGameObject)
.Value;
BombManager = BombManager.GetInstance();
NewGame();
}
private void Awake()
{
if (m_bombManager == null)
{
m_bombManager = this;
}
else if (m_bombManager != this)
{
Destroy(gameObject);
}
}
void Awake()
{
if (instance)
{
Destroy(this.gameObject);
}
else
{
instance = this;
}
}
void Awake()
{
if (_sSingleton != null && _sSingleton != this)
{
Destroy(this.gameObject);
}
else
{
_sSingleton = this;
}
}
/// <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;
}
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);
}
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());
}
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]);
}
}
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());
}
}
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);
}
}
}
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));
}
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++;
}
}
//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();
}
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();
}
// 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);
}
void OnDestroy()
{
Instance = null;
}