/// <summary>
/// M_updateView_arena_final
/// </summary>
private void M_updateView_arena_final()
{
if (ArenaManager.computeGuessNumber() > 0)
{
label_arena_times.gameObject.SetActive(true);
}
label_arena_times.text = ArenaManager.computeGuessNumber().ToString();
label_prefix.text = LanguageConfigManager.Instance.getLanguage("ArenaNavigateTip_6");
//label_Rank.text = ArenaManager.instance.self.rank.ToString ();
label_ChallengeTimes.text = ArenaManager.computeGuessNumber().ToString();
initRankInfo();
//label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_" + myRank + "_2");
//if(ArenaManager.instance.state == ArenaManager.STATE_64_32)
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_1_2");
//else if(ArenaManager.instance.state == ArenaManager.STATE_32_16)
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_2_2");
//else if(ArenaManager.instance.state == ArenaManager.STATE_16_8)
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_3_2");
//else if(ArenaManager.instance.state == ArenaManager.STATE_8_4)
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_4_2");
//else if(ArenaManager.instance.state == 6 || ArenaManager.instance.state == 7)
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_5_2");
//else
// label_Rank.text = LanguageConfigManager.Instance.getLanguage("Arena14_0_2");
}
void UpdateFacingDirInput()
{
ArenaManager arenaManager = ArenaManager.Instance;
Vector3 cameraForward = arenaManager.arenaCamera.transform.forward;
Vector3 cameraRight = arenaManager.arenaCamera.transform.right;
cameraForward.y = 0;
cameraRight.y = 0;
if (controllerType == ControllerType.Joystick)
{
float horRot = Input.GetAxis("Rotation Horizontal" + suffix);
float verRot = Input.GetAxis("Rotation Vertical" + suffix);
characterInput.facingDir =
(cameraRight * horRot) +
(cameraForward * verRot);
characterInput.facingDir.y = 0;
}
else if (controllerType == ControllerType.KeyboardAndMouse)
{
Vector3 pos = new Vector3(Input.mousePosition.x, Input.mousePosition.y, 0f);
Ray ray = arenaManager.arenaCamera.GetComponent <Camera>().ScreenPointToRay(pos);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit, float.MaxValue, LayerMask.GetMask("MousePositionDetector")))
{
Vector3 targetPos = raycastHit.point;
targetPos.y = GetComponentInParent <CharacterMovementController>().transform.position.y;
characterInput.facingDir = targetPos - transform.position;
}
}
}
public void Update(ArenaManager world)
{
for (int i = buffs.Count - 1; i >= 0; i--)
{
if (buffs[i].Update())
{
for (int k = 0; k < unit.Character.CharacterEvents[CharacterEventTypes.OnBuffExpired].Count; k++)
{
if (unit.Character.CharacterEvents[CharacterEventTypes.OnBuffExpired][k].Buff == buffs[i])
{
unit.Character.CharacterEvents[CharacterEventTypes.OnBuffExpired][k].ApplyScript(
new SpellScriptInvokeArgs(0, buffs[i].caster, unit, world, null, null));
}
}
for (int j = 0; j < buffs[i].Auras.Count; j++)
{
buffs[i].Auras[j].Reverse(unit);
}
buffs[i].Dispose();
buffs.RemoveAt(i);
}
}
}
public void Dispose()
{
world = null;
caster = null;
target = null;
spell = null;
}
public void Apply(Unit caster, Unit target, Spell spell, ArenaManager world)
{
var direction = Vector3.Cross(caster.transform.up, (target.transform.position - caster.transform.position).normalized);
target.GetComponent <Rigidbody>().MovePosition(target.transform.position +
new Vector3(direction.x * horizontalValue, direction.y * verticalValue, direction.z * horizontalValue));
}
void Awake()
{
world = ArenaManager.Instanse;
mainCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent <Camera>();
humanPlayer = GameObject.FindGameObjectWithTag("Player");
PlayerUnit = humanPlayer.GetComponent <Unit>();
ButtonController = GetComponent <ButtonController>();
lastScreenWidth = 0;
lastScreenHeight = 0;
lastTarget = null;
playerFrameNewUI.Initialize();
playerFrameNewUI.SetUnit(PlayerUnit);
targetFrameNewUI.Initialize();
targetFrameNewUI.SetUnit(null);
TargetLost += targetFrameNewUI.OnTargetLost;
TargetSet += targetFrameNewUI.OnTargetSet;
TargetSwitch += targetFrameNewUI.OnTargetSwitch;
playerBuffsNewUI.Initialize(PlayerUnit);
ScreenResized += playerBuffsNewUI.OnScreenResize;
targetBuffsNewUI.Initialize(PlayerUnit.character.target);
TargetLost += targetBuffsNewUI.OnTargetLost;
TargetSet += targetBuffsNewUI.OnTargetSet;
TargetSwitch += targetBuffsNewUI.OnTargetSwitch;
targetBuffsNewUI.gameObject.SetActive(false);
ScreenResized += targetBuffsNewUI.OnScreenResize;
ScreenResized += OnScreenResize;
}
public void Initialize(ActionBar newActionBar, ButtonSlot buttonSlot)
{
Image = gameObject.GetComponent <Image>();
actionBar = newActionBar;
rectTransform = GetComponent <RectTransform>();
ButtonSlot = buttonSlot;
ArenaManager currentWorld = actionBar.playerInterface.world;
if (currentWorld.SpellLibrary.HasSpell(itemId))
{
if (currentWorld.SpellIcons.ContainsKey(currentWorld.SpellLibrary.GetSpell(itemId).iconName))
{
Image.sprite = currentWorld.SpellIcons[currentWorld.SpellLibrary.GetSpell(itemId).iconName];
}
else
{
Image.sprite = currentWorld.SpellIcons["Default"];
}
}
else
{
Image.sprite = currentWorld.SpellIcons["Default"];
}
if (currentWorld.PlayerUnit.Character.Spells.HasSpell(itemId))
{
spell = currentWorld.PlayerUnit.Character.Spells.GetSpell(itemId);
}
else
{
spell = null;
}
}
public void ExitBattle(ArenaManager subject)
{
foreach (SkinnedMeshRenderer s in _meshRenderers)
{
s.enabled = false;
}
}
public void Initialize(ArenaManager newWorld, Unit newCaster, Unit newTarget, Spell newSpell)
{
world = newWorld;
caster = newCaster;
target = newTarget;
spell = newSpell;
}
private void OnGlobalStartBattle(ArenaManager instance)
{
//healthBar.SetActive(true);
//healthBar.transform.GetChild( 0 ).gameObject.GetComponent<Image>().fillAmount = 1f;
healthBarOutside.GetComponent <Image>().enabled = true;
healthBarInside.GetComponent <Image>().enabled = true;
}
private void OnGlobalEndBattle(ArenaManager arenaManager)
{
InBattle = false;
leftManaBarPS.Stop();
rightManaBarPS.Stop();
}
void Awake()
{
// Confirm singleton instance is active
if (_inst == null)
{
_inst = this;
}
else if (_inst != this)
{
GameObject.Destroy(this);
}
if (_player == null && GameObject.Find("Player") != null)
{
_player = GameObject.Find("Player").GetComponent <PlayerController>();
}
if (timerText == null && GameObject.Find("Game Timer") != null)
{
timerText = GameObject.Find("Game Timer").GetComponent <TextMeshProUGUI>();
}
if (scoreText == null && GameObject.Find("Score Text") != null)
{
scoreText = GameObject.Find("Score Text").GetComponent <TextMeshProUGUI>();
}
}
protected override IEnumerator InnerDoGroupAbility(Transform groupTransform)
{
_horn.transform.position = groupTransform.position + new Vector3(0f, 1f, 0f);
_horn.transform.SetParent(groupTransform);
ArenaManager arena = groupTransform.GetComponent <ImpGroupAi>().Target.Target.GetComponent <ArenaBoss>()
.Arena;
CombatSystem[] spectatorsSystems = arena.GetComponentsInChildren <CombatSystem>();
float timer = 0f;
int i = 0;
while (timer <= data.ActivatedDuration)
{
if (spectatorsSystems[i].enabled)
{
spectatorsSystems[i].StartAttack(data.AssociatedAttack.GetAttack(), arena.Boss.transform);
}
yield return(null);
timer += Time.deltaTime;
i = i < spectatorsSystems.Length - 1 ? i + 1 : 0;
}
}
public void SetUp()
{
GameManager.gameManager.PoolManager.GenerateEnemyShipsPoolDisctionary(GetAllUsedEnemiesTags);
/*string newString = "";
* foreach (EnemyShipPoolTag tg in GetAllUsedEnemiesTags)
* newString += tg + ", ";
* GameManager.gameManager.ShowDebugText(newString);*/
wavesWaitingToBeLaunched = new List <EnemyWave>();
wavesToRemoveFromWait = new List <EnemyWave>();
enemySpawingDropParameters.SetUp();
foreach (EnemyWave wave in allWaves)
{
wave.SetUp(this);
}
ArenaManager arenaManager = ArenaManager.arenaManager;
if (arenaManager != null)
{
arenaManager.ChoseNextTimeToCheck();
arenaManager.ChoseNextKillsToCheck();
}
}
// Token: 0x060012D7 RID: 4823 RVA: 0x0020DE64 File Offset: 0x0020C064
public void Recv_MSG_RESP_ARENA_BOARDDATA(MessagePacket MP)
{
ArenaManager.Instance.m_ArenaTargetHint.AllianceTagTag = MP.ReadString(3, -1);
ArenaManager.Instance.m_ArenaTargetHint.Name = MP.ReadString(13, -1);
ArenaManager.Instance.m_ArenaTargetHint.Place = (uint)((byte)MP.ReadULong(-1));
ArenaManager.Instance.m_ArenaTargetHint.HeroData = new ArenaTargetHeroDataType[5];
ArenaManager instance = ArenaManager.Instance;
instance.m_ArenaTargetHint.Place = instance.m_ArenaTargetHint.Place + 1u;
for (int i = 0; i < 5; i++)
{
ArenaManager.Instance.m_ArenaTargetHint.HeroData[i].ID = MP.ReadUShort(-1);
ArenaManager.Instance.m_ArenaTargetHint.HeroData[i].Level = MP.ReadByte(-1);
ArenaManager.Instance.m_ArenaTargetHint.HeroData[i].Rank = MP.ReadByte(-1);
ArenaManager.Instance.m_ArenaTargetHint.HeroData[i].Star = MP.ReadByte(-1);
ArenaManager.Instance.m_ArenaTargetHint.HeroData[i].Equip = MP.ReadByte(-1);
MP.ReadInt(-1);
}
ArenaManager.Instance.m_ArenaTargetHint.Head = ArenaManager.Instance.m_ArenaTargetHint.HeroData[0].ID;
Transform parent = this.hintTarget.transform.parent;
this.hintTarget.transform.SetParent(this.hintCenter);
Vector2 anchoredPosition = this.hintTarget.GetComponent <RectTransform>().anchoredPosition;
this.hintTarget.transform.SetParent(parent);
this.hintTarget.transform.SetSiblingIndex(11);
float num = anchoredPosition.y + 410f;
num = Mathf.Clamp(num, -190f, 150f);
GUIManager.Instance.m_Arena_Hint.Show(this.hintTarget, -40f, num, 0);
}
/// <summary>
/// Constructs a new WallTrap. The square coordinates should be
/// the square the WallTrap will actually occupy, not the wall it is
/// attached to!
/// </summary>
/// <param name="env"></param>
/// <param name="facing"></param>
/// <param name="xSquare"></param>
/// <param name="ySquare"></param>
protected WallTrap(ArenaManager env, Direction facing, int xSquare, int ySquare)
: base(env, xSquare, ySquare)
{
this.facing = facing;
this.wallSquareX = xSquare;
this.wallSquareY = ySquare;
switch (facing)
{
case Direction.UP:
this.wallSquareY++;
break;
case Direction.DOWN:
this.wallSquareY--;
break;
case Direction.RIGHT:
this.wallSquareX--;
break;
case Direction.LEFT:
this.wallSquareX++;
break;
default:
throw new NotImplementedException();
}
}
//[SerializeField] private int _hitsCount=0;
public void Init(EnemySpawner enemySpawner, float speed, KeySpawner keySpawner, ArenaManager manager, UI ui)
{
_ui = ui;
_enemySpawner = enemySpawner;
_keySpawner = keySpawner;
_arenaManager = manager;
velocity_modifier = speed;
}
public void PrepareBattle(ArenaManager subject)
{
foreach (SkinnedMeshRenderer s in _meshRenderers)
{
s.enabled = true;
}
subject.NotifyBattlePrepared(this);
}
void Awake()
{
if(instance){
return;
}
instance = this;
}
public void MoveCamera(ArenaManager nextArena)
{
//do only if not already running a coroutine
if (moveToNextArena == null)
{
moveToNextArena = StartCoroutine(MoveToNextArena(nextArena));
}
}
public void initPrefs(ArenaPlayer c, ArenaManager m, int t = 30, int h = 5)
{
creator = c;
manager = m;
time = t;
heal = h;
}
public void Dispose()
{
caster = null;
target = null;
world = null;
spell = null;
spellInfo = null;
}
public void ExitBattle(ArenaManager subject)
{
_collider.enabled = false;
foreach (ParticleSystem p in _particles)
{
p.Stop();
}
}
public void EnterBattle(ArenaManager subject)
{
_collider.enabled = true;
foreach (ParticleSystem p in _particles)
{
p.Play();
}
}
private void OnGlobalEndBattle(ArenaManager obj)
{
DeactivateHealthBar();
_bossHitPoints.OnHpChanged -= OnHpChanged;
_bossHitPoints = null;
_bossStartHp = 0f;
}
// Start is called before the first frame update
void Start()
{
image = GetComponent <Image>();
/*
* if(Hero.arenaHead != null)
* image.sprite = Hero.arenaHead.img; */
arenaManager = Camera.main.transform.GetComponent <ArenaManager>();
}
public WaveTracker(ArenaMap arena, ArenaManager env)
{
this.arena = arena;
this.env = env;
this.enemies = new Queue<EnemyTracker>();
this.toBeSpawned = new Queue<Enemy>();
loadDefaultEnemies();
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
glowMaterial.SetColor("_Color", Color.red);
glowMaterial.SetFloat("_Intensity", 3.5f);
}
public void Update(Unit target, ArenaManager world)
{
tickTimeLeft -= Time.deltaTime;
if (tickTimeLeft <= 0)
{
tickTimeLeft = tickTime + tickTimeLeft;
world.ApplyEffect(Buff.caster, target, effect, Buff.spellId);
}
}
void Start()
{
rb = GetComponent <Rigidbody2D>();
ar_manager = ArenaManager.getArenaManager();
current_bullet_ID = 0;
is_shooting_on_cooldown = false;
shooting_cooldown_time = 5;
}
public void UpdateUnit(ArenaManager world)
{
if (moveTimer > 0)
{
moveTimer -= Time.deltaTime;
}
Character.Update(this, world);
}
public SpellScriptInvokeArgs(int newSpellId, Unit newCaster, Unit newTarget,
ArenaManager newWorld, Spell newSpell, SpellInfo newSpellInfo)
{
spellId = newSpellId;
caster = newCaster;
target = newTarget;
world = newWorld;
spell = newSpell;
spellInfo = newSpellInfo;
}
private void OnGlobalEndBattle(ArenaManager obj)
{
lockedCamera.gameObject.SetActive(false);
_cinemachineFreeLook.gameObject.SetActive(true);
battleEnded = true;
// _cinemachineVirtualCameraLock.LookAt = _currentLeader;
// _cinemachineFreeLook.m_RecenterToTargetHeading.m_enabled = true;
}
public SpikeTrap(ArenaManager env, int xCenter, int yCenter, int floorSquareX, int floorSquareY)
: base(env, floorSquareX, floorSquareY)
{
this.damagePerTick = baseDamagePerTick;
this.nextDamagePerTick = damagePerTick * upgradeDamageFactor;
this.slowFactor = baseSlowFactor;
this.nextSlowFactor = this.slowFactor * slowUpgradeFactor;
this.xCenter = xCenter;
this.yCenter = yCenter;
}
public BasicEnemy(ArenaMap arena, ArenaManager manager, int startX, int startY, float scale)
: base(manager, arena, scale)
{
this.xCenter = startX;
this.yCenter = startY;
Facing = Direction.UP;
this.health = MAX_HEALTH;
hasGoal = false;
hasReachedGoal = false;
}
protected WallProjectileTrap(ArenaManager env, int centerX, int centerY, int xSquare, int ySquare, Direction facing)
: base(env, facing, xSquare, ySquare)
{
this.projectileDamage = BaseProjectileDamage;
this.nextProjectileDamage = BaseProjectileDamage * projectileDamageScalingFactor;
position = new Point(centerX, centerY);
visualPosition = new Point(centerX, centerY);
switch (facing)
{
case Direction.UP:
visualPosition.Y -= imageHeight / 4;
mainTexture = UpTexture;
mainHightlightTexture = UpHighlightTexture;
break;
case Direction.DOWN:
visualPosition.Y += imageHeight / 4;
mainTexture = DownTexture;
mainHightlightTexture = DownHighlightTexture;
break;
case Direction.LEFT:
visualPosition.X -= imageWidth / 4;
mainTexture = LeftTexture;
mainHightlightTexture = LeftHighlightTexture;
break;
case Direction.RIGHT:
visualPosition.X += imageWidth / 4;
mainTexture = RightTexture;
mainHightlightTexture = RightHighlightTexture;
break;
default:
throw new NotImplementedException();
}
projectilePositions = new Queue<Point>();
}
public Build(ArenaManager env, int xCenter, int yCenter, int xSquare, int ySquare)
: base(env, xSquare, ySquare)
{
this.xCenter = xCenter;
this.yCenter = yCenter;
}
public MineWall(ArenaManager env, int xCenter, int yCenter, int floorSquareX, int floorSquareY)
: base(env, floorSquareX, floorSquareY)
{
this.xCenter = xCenter;
this.yCenter = yCenter;
}
void Awake()
{
DontDestroyOnLoad(transform.gameObject);
end = false;
GameObject GrandPa = new GameObject();
instance = this;
GrandPa.name = "GrandPa";
papaSol = new GameObject();
papaSol.name = "PapaSol";
papaSol.transform.parent = GrandPa.transform;
papaMur = new GameObject();
papaMur.name = "PapaMur";
papaMur.transform.parent = GrandPa.transform;
wallHeight = wall.transform.localScale.y / 2;
floorSide = floor.transform.localScale.x / 2;
arena = new GameObject[height, width];
wallArena = new int[height, width][];
wallObject = new GameObject[height, width][];
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
// Création du tableau des murs dans la case [i, j]
wallArena[i, j] = new int[4];
wallObject[i, j] = new GameObject[4];
}
}
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
// Création du sol de l'arène et envoi dans la fonction de création des murs random
WallCreation(i, j);
GameObject currentFloor = Instantiate(floor, new Vector3(i, 0, j), Quaternion.identity) as GameObject;
CubeScript CS = currentFloor.GetComponent<CubeScript>();
CS.tile = new int[] { i, j };
listCubeScript.Add(CS);
arena[i, j] = currentFloor;
currentFloor.transform.parent = papaSol.transform;
}
}
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
WallDestruct(i, j);
}
}
//Check voisins
CheckNeighboors();
while (end == false)
{
Colorate();
Check();
}
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
arena[i, j].GetComponent<Renderer>().material.color = Color.white;
}
}
GameObject go = Instantiate(player, new Vector3(0, player.transform.localScale.y / 2, 0), Quaternion.identity) as GameObject;
Camera.main.transform.parent = go.transform;
Camera.main.transform.localPosition = new Vector3(0, 10, 0);
GameObject go2 = Instantiate(player, new Vector3(width - 1, player.transform.localScale.y / 2, 0), Quaternion.identity) as GameObject;
GameObject go3 = Instantiate(player, new Vector3(0, player.transform.localScale.y / 2, height - 1), Quaternion.identity) as GameObject;
GameObject go4 = Instantiate(player, new Vector3(width - 1, player.transform.localScale.y / 2, height - 1), Quaternion.identity) as GameObject;
players = new GameObject[10];
players[1] = go;
players[2] = go2;
players[3] = go3;
players[4] = go4;
}
public void EndSession(ArenaManager zone)
{
myPhotonView.RPC("DecommissionArena", PhotonTargets.All, zone.arenaID);
}
public QuickEnemy(ArenaMap arena, ArenaManager env, int startX, int startY, float scale)
: base(arena, env, startX, startY, scale)
{
}
/// <summary>
/// Creates a new GunTrap at the specified location
/// </summary>
/// <param name="arena"></param>
/// <param name="env"></param>
/// <param name="centerX">The centerX of the gun</param>
/// <param name="centerY">The centerY of the gun</param>
/// <param name="facing"></param>
public DartTrap(ArenaManager env, int centerX, int centerY, int xSquare, int ySquare, Direction facing)
: base(env, centerX, centerY, xSquare, ySquare, facing)
{
this.poisonDamage = BasePoisonDamage;
this.nextPoisonDamage = poisonDamage * PoisonDamageScalingFactor;
}
// 对象进入场景，在这里初始化各种数据， 资源， 模型等
// 传入数据。
override public void OnEnterWorld()
{
base.OnEnterWorld();
LoggerHelper.Info("Avatar name: " + name);
// 在调用该函数前， 数据已经通过EntityAttach 和 EntityCellAttach 同步完毕
CreateModel();
inventoryManager = new InventoryManager(this);
bodyenhanceManager = new BodyEnhanceManager(this);
skillManager = new PlayerSkillManager(this);
battleManger = new PlayerBattleManager(this, skillManager as PlayerSkillManager);
doorOfBurySystem = new DoorOfBurySystem();
runeManager = new RuneManager(this);
towerManager = new TowerManager(this);
missionManager = new MissionManager(this);
taskManager = new TaskManager(this, (int)taskMain);
marketManager = new MarketManager(this);
friendManager = new FriendManager(this);
operationSystem = new OperationSystem(this);
sanctuaryManager = new SanctuaryManager(this);
arenaManager = new ArenaManager(this);
dailyEventSystem = new DailyEventSystem(this);
rankManager = new RankManager(this);
campaignSystem = new CampaignSystem(this);
wingManager = new WingManager(this);
rewardManager = new RewardManager(this);
occupyTowerSystem = new OccupyTowerSystem(this);
TipManager.Init();
DragonMatchManager.Init();
fumoManager = new FumoManager(this);
MailManager.Instance.IsMailInfoDirty = true;
TongManager.Instance.Init();
GuideSystem.Instance.AddListeners();
StoryManager.Instance.AddListeners();
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnNormalAttack, NormalAttack);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnPowerChargeStart, PowerChargeStart);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnPowerChargeInterrupt, PowerChargeInterrupt);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnPowerChargeComplete, PowerChargeComplete);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnSpellOneAttack, SpellOneAttack);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnSpellTwoAttack, SpellTwoAttack);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnSpellThreeAttack, SpellThreeAttack);
EventDispatcher.AddEventListener(Events.UIBattleEvent.OnSpellXPAttack, SpecialAttack);
EventDispatcher.AddEventListener<int>(Events.UIBattleEvent.OnSpriteSkill, OnSpriteSkill);
EventDispatcher.AddEventListener<uint>(Events.GearEvent.Teleport, Teleport);
EventDispatcher.AddEventListener<uint, int, int, int>(Events.GearEvent.Damage, SetDamage);
EventDispatcher.AddEventListener<int, bool>(Events.InstanceEvent.InstanceLoaded, InstanceLoaded);
EventDispatcher.AddEventListener<ushort>(Events.OtherEvent.MapIdChanged, OnMapChanged);
EventDispatcher.AddEventListener<ulong>(Events.OtherEvent.Withdraw, Withdraw);
EventDispatcher.AddEventListener(Events.OtherEvent.DiamondMine, DiamondMine);
EventDispatcher.AddEventListener(Events.OtherEvent.CheckCharge, CheckCharge);
EventDispatcher.AddEventListener(Events.OtherEvent.Charge, Charge);
EventDispatcher.AddEventListener(ON_TASK_GUIDE, TaskGuide);
EventDispatcher.AddEventListener(ON_END_TASK_GUIDE, EndTaskGuide);
EventDispatcher.AddEventListener<int, int>(ON_TASK_MISSION, MissionOpen);
EventDispatcher.AddEventListener(Events.AIEvent.DummyThink, DummyThink);
EventDispatcher.AddEventListener(Events.StoryEvent.CGBegin, ProcCGBegin);
EventDispatcher.AddEventListener(Events.StoryEvent.CGEnd, ProcCGEnd);
EventDispatcher.AddEventListener<string>(Events.GearEvent.TrapBegin, ProcTrapBegin);
EventDispatcher.AddEventListener<string>(Events.GearEvent.TrapEnd, ProcTrapEnd);
EventDispatcher.AddEventListener(Events.GearEvent.LiftEnter, ProcLiftEnter);
EventDispatcher.AddEventListener<int>(Events.GearEvent.PathPointTrigger, PathPointTrigger);
EventDispatcher.AddEventListener(Events.DirecterEvent.DirActive, DirActive);
EventDispatcher.AddEventListener<int>(Events.EnergyEvent.BuyEnergy, BuyEnergy);
EventDispatcher.AddEventListener(ON_VIP_REAL_STATE, OnVIPRealState);
EventDispatcher.AddEventListener<int>(Events.DiamondToGoldEvent.GoldMetallurgy, GoldMetallurgy);
EventDispatcher.AddEventListener(MainUIDict.MainUIEvent.AFFECTUP, OnBattleBtnPressed);
EventDispatcher.AddEventListener(MainUIDict.MainUIEvent.OUTPUTUP, OnBattleBtnPressed);
EventDispatcher.AddEventListener(MainUIDict.MainUIEvent.MOVEUP, OnBattleBtnPressed);
EventDispatcher.AddEventListener(MainUIDict.MainUIEvent.NORMALATTACK, OnBattleBtnPressed);
EventDispatcher.AddEventListener(MainUIDict.MainUIEvent.PLAYERINFOBGUP, OnBattleBtnPressed);
EventDispatcher.AddEventListener("MainUIControllStickPressed", OnBattleBtnPressed);
EventDispatcher.AddEventListener<Vector3>(Events.GearEvent.CrockBroken, CrockBroken);
EventDispatcher.AddEventListener<bool, bool, Vector3>(Events.GearEvent.ChestBroken, ChestBroken);
EventDispatcher.AddEventListener<GameObject, Vector3, float>(MogoMotor.ON_MOVE_TO_FALSE, OnMoveToFalse);
EventDispatcher.AddEventListener(Events.OtherEvent.BossDie, BossDie);
EventDispatcher.AddEventListener<int, bool>(Events.InstanceEvent.InstanceLoaded, SetCampControl);
timerID = TimerHeap.AddTimer<bool>(1000, 100, SyncPos, true);
checkDmgID = TimerHeap.AddTimer(0, 1000, CheckDmgBase);
syncHpTimerID = TimerHeap.AddTimer(10000, 5000, SyncHp);
skillFailoverTimer = TimerHeap.AddTimer(1000, 3000, SkillFailover);
TimerHeap.AddTimer(5000, 0, GetServerTickReq);
//rateTimer = TimerHeap.AddTimer(1000, 3000, CheckRate);
CheckCharge();
GetWingBag();
MogoTime.Instance.InitTimeFromServer();
MogoUIManager.Instance.LoadUIResources();
TimerHeap.AddTimer(500, 0, EventDispatcher.TriggerEvent, Events.RuneEvent.GetBodyRunes);
TimerHeap.AddTimer(500, 0, marketManager.GiftRecordReq);
if (IsNewPlayer)
{
CurMissionID = 10100;
CurMissionLevel = 1;
missionManager.EnterMissionReq(CurMissionID, CurMissionLevel);
}
if (PlatformSdkManager.Instance)
TimerHeap.AddTimer(1000, 60000, PlatformSdkManager.Instance.OnSetupNotification);
}
/// <summary>
/// Creates a new GunTrap at the specified location
/// </summary>
/// <param name="arena"></param>
/// <param name="env"></param>
/// <param name="centerX">The centerX of the gun</param>
/// <param name="centerY">The centerY of the gun</param>
/// <param name="facing"></param>
public CannonTrap(ArenaManager env, int centerX, int centerY, int xSquare, int ySquare, Direction facing)
: base(env, centerX, centerY, xSquare, ySquare, facing)
{
}
public IEnumerator GotoZoneSequence(Zone newZone)
{
GUIManager.Instance.loadingGUI.Enable(true);
yield return new WaitForSeconds(1.5f);
ActiveZone = newZone;
if(ActiveZone.zoneType == ZoneType.arena)
{
ActiveArena = ActiveZone.gameObject.GetComponent<ArenaManager>();
if(ActiveArena == null)
{
Debug.LogError("no bloody arena");
}
activityState = PlayerActivityState.arena;
avatarObject.transform.position = SpawnPoint.position;
}
else if(ActiveZone.zoneType == ZoneType.town)
{
activityState = PlayerActivityState.idle;
avatarObject.transform.position = cachedTownPosition;
}
}
// setting up some skills, get to know its own components
public virtual void Initialise (ArenaManager ownerArena, int newViewId) {
Debug.LogWarning("initialising ai");
arena = ownerArena;
myPhotonView = GetComponent<PhotonView>();
myPhotonView.viewID = newViewId;
ownerID = myPhotonView.ownerId;
_myTransform = transform;
MakeSpawnPool();
//skillChances = new float[skills.Length];
foreach(AnimationState anim in myAnimation)
{
if(anim.name == idleAnim.name)
{
anim.layer = 0;
}
else if(anim.name == deathAnim.name)
{
anim.layer = 5;
}
else if(anim.name == runningAnim.name)
anim.layer = 0;
}
EnterAIState(AIState.initialised);
}
public ToughEnemy(ArenaMap arena, ArenaManager env, int startX, int startY, float scale)
: base(arena, env, startX, startY, scale)
{
totalPoisonDamage = 0;
}
