public bool CollectArrow(ArrowTypes arrowType)
{
if ((((MyMatchVariants)this.Level.Session.MatchSettings.Variants).ArcherGhosts) &&
(sprite.CurrentAnimID != "dodge") &&
(hasArrow == false))
{
AddArrow(arrowType, archerSounds.ArrowRecover);
return(true);
}
return(false);
}
public override void ShootArrow()
{
ArrowTypes[] at = new ArrowTypes[1];
if (((MyMatchVariants)Level.Session.MatchSettings.Variants).InfiniteArrows)
{
at[0] = this.Arrows.UseArrow();
this.Arrows.AddArrows(at);
}
base.ShootArrow();
if (((MyMatchVariants)Level.Session.MatchSettings.Variants).InfiniteArrows)
{
this.Arrows.AddArrows(at);
}
}
public void AddArrow(ArrowTypes arrowType, SFX sound)
{
this.halo.Position = new Vector2(0f, -12f);
this.halo.Zoom = haloProperties.Zoom * 1.5f;
this.halo.Rotation = 1.5f;
if (this.sprite.CurrentAnimID == "normal")
{
this.sprite.Play("happy", false);
}
ghostArrow = arrowType;
sound.Play(base.X, 1f);
hasArrow = true;
}
public static ArrowHead Create(ArrowTypes type, ArrowPos pos, double len, double width)
{
ArrowHead a = default(ArrowHead);
double w2 = width / 2;
if (pos == ArrowPos.END)
{
if (type == ArrowTypes.CROSS)
{
a.p0 = CadVertex.Create(0, 0, 0);
a.p1 = CadVertex.Create(-len, w2, w2);
a.p2 = CadVertex.Create(-len, w2, -w2);
a.p3 = CadVertex.Create(-len, -w2, -w2);
a.p4 = CadVertex.Create(-len, -w2, w2);
}
else if (type == ArrowTypes.PLUS)
{
a.p0 = CadVertex.Create(0, 0, 0);
a.p1 = CadVertex.Create(-len, w2, 0);
a.p2 = CadVertex.Create(-len, 0, -w2);
a.p3 = CadVertex.Create(-len, -w2, 0);
a.p4 = CadVertex.Create(-len, 0, w2);
}
}
else
{
if (type == ArrowTypes.CROSS)
{
a.p0 = CadVertex.Create(0, 0, 0);
a.p1 = CadVertex.Create(len, w2, w2);
a.p2 = CadVertex.Create(len, w2, -w2);
a.p3 = CadVertex.Create(len, -w2, -w2);
a.p4 = CadVertex.Create(len, -w2, w2);
}
else if (type == ArrowTypes.PLUS)
{
a.p0 = CadVertex.Create(0, 0, 0);
a.p1 = CadVertex.Create(len, w2, 0);
a.p2 = CadVertex.Create(len, 0, -w2);
a.p3 = CadVertex.Create(len, -w2, 0);
a.p4 = CadVertex.Create(len, 0, w2);
}
}
return(a);
}
public override void Upgrade(int nextLevel)
{
base.Upgrade(nextLevel);
//check money available for upgrade.
if (GameController.instance.waveManager.Money < UpgradeCost(nextLevel))
{
GameController.instance.buttonManager.AlertDisplay("Not Enough Money");
return;
}
else
{
cost += UpgradeCost(nextLevel);
GameController.instance.waveManager.Money -= UpgradeCost(nextLevel);
}
switch (nextLevel)
{
case Constants.NORMAL_TOWER_FROZEN_LEVEL1:
level = Constants.NORMAL_TOWER_FROZEN_LEVEL1;
transform.GetChild(0).GetComponent <Animator>().Play("NormalFrozenLevelOne");
arrowType = ArrowTypes.FrozenLevel1;
break;
case Constants.NORMAL_TOWER_FIRE_LEVEL1:
level = Constants.NORMAL_TOWER_FIRE_LEVEL1;
damageMultiplier = Constants.NORMAL_TOWER_FIRE_DAMAGE_MULTIPLIER_LEVEL1;
transform.GetChild(0).GetComponent <Animator>().Play("NormalFireLevelOne");
arrowType = ArrowTypes.FireLevel1;
break;
case Constants.NORMAL_TOWER_FIRE_LEVEL2:
level = Constants.NORMAL_TOWER_FIRE_LEVEL2;
damageMultiplier = Constants.NORMAL_TOWER_FIRE_DAMAGE_MULTIPLIER_LEVEL2;
transform.GetChild(0).GetComponent <Animator>().Play("NormalFireLevelTwo");
arrowType = ArrowTypes.FireLevel2;
break;
case Constants.NORMAL_TOWER_FROZEN_LEVEL2:
level = Constants.NORMAL_TOWER_FROZEN_LEVEL2;
//damageMultiplier = Constants.NORMAL_TOWER_FIRE_DAMAGE_MULTIPLIER_LEVEL2;
transform.GetChild(0).GetComponent <Animator>().Play("NormalFrozenLevelTwo");
arrowType = ArrowTypes.FrozenLevel2;
break;
}
}
public void SetArrowType(ArrowTypes arrowType)
{
switch (arrowType)
{
case ArrowTypes.None:
ArrowBlock.SetActive(false);
break;
case ArrowTypes.Upgrade:
ArrowBlock.SetActive(true);
ArrowText.text = LanguageManager.Instance.GetText("CardBase_Upgradable");
break;
case ArrowTypes.StorageIncrease:
ArrowBlock.SetActive(true);
ArrowText.text = LanguageManager.Instance.GetText("CardBase_StorageIncrease");
break;
}
}
public static Arrow Create(ArrowTypes type, LevelEntity owner, Vector2 position, float direction, int?overrideCharacterIndex = null, int?overridePlayerIndex = null)
{
patch_Arrow arrow;
if ((int)type > 10)
{
// custom arrow
Type ctype = ModArrow.ModArrowTypes[(int)type];
arrow = (patch_Arrow)ctype.GetConstructor(ModLoader.mm.ModLoader._EmptyTypeArray).Invoke(ModLoader.mm.ModLoader._EmptyObjectArray);
arrow.OverrideCharacterIndex = overrideCharacterIndex;
arrow.OverridePlayerIndex = overridePlayerIndex;
arrow.Init(owner, position, direction);
}
else
{
// vanilla arrow
return(orig_Create(type, owner, position, direction, overrideCharacterIndex, overridePlayerIndex));
}
return(arrow);
}
void OnEnable()
{
base.OnEnable();
doubleDamage = GameController.instance.UpgradedItem[Constants.UPGRADE_BASIC_DOUBLE_DAMAGE_INDEX];
if (GameController.instance.UpgradedItem[Constants.UPGRADE_BASIC_COST_INDEX])
{
cost = (int)(Constants.NORMAL_TOWER_COST * Constants.UPGRADE_BASIC_COST_MULTIPLY);
}
else
{
cost = Constants.NORMAL_TOWER_COST;
}
arrowType = ArrowTypes.Normal;
towerType = TowerTypes.Normal;
//upgrade speed shooting
if (GameController.instance.UpgradedItem[Constants.UPGRADE_BASIC_ATTACK_SPEED_INDEX])
{
AttackSpeedMultiplier = Constants.UPGRADE_BASIC_ATTACK_SPEED_MULTIPLY;
}
}
public override void Added()
{
base.Added();
this.spawningGhost = false;
this.diedFromPrism = false;
if (((MyMatchVariants)Level.Session.MatchSettings.Variants).VarietyPack[this.PlayerIndex])
{
this.Arrows.Clear();
this.Arrows.SetMaxArrows(10);
var arrows = new ArrowTypes[] {
ArrowTypes.Bomb,
ArrowTypes.SuperBomb,
ArrowTypes.Laser,
ArrowTypes.Bramble,
ArrowTypes.Drill,
ArrowTypes.Bolt,
ArrowTypes.Toy,
ArrowTypes.Feather,
ArrowTypes.Trigger,
ArrowTypes.Prism
};
// Randomize. Couldn't get static method to work.
Random rand = new Random();
// For each spot in the array, pick
// a random item to swap into that spot.
for (int i = 0; i < arrows.Length - 1; i++)
{
int j = rand.Next(i, arrows.Length);
ArrowTypes temp = arrows[i];
arrows[i] = arrows[j];
arrows[j] = temp;
}
this.Arrows.AddArrows(arrows);
}
}
void OnDisable()
{
arrowType = ArrowTypes.Normal;
}
public void DrawArrow(DrawPen pen, Vector3d pt0, Vector3d pt1, ArrowTypes type, ArrowPos pos, double len, double width)
{
DrawUtil.DrawArrow(DrawLine, pen, pt0, pt1, type, pos, len / DC.WorldScale, width / DC.WorldScale);
}
public static void DrawArrow(
Action <DrawPen, Vector3d, Vector3d> DrawLine,
DrawPen pen,
Vector3d pt0,
Vector3d pt1,
ArrowTypes type,
ArrowPos pos,
double len,
double width)
{
DrawLine(pen, pt0, pt1);
Vector3d d = pt1 - pt0;
double dl = d.Length;
if (dl < 0.00001)
{
return;
}
Vector3d tmp = new Vector3d(dl, 0, 0);
double angle = Vector3d.CalculateAngle(tmp, d);
Vector3d normal = CadMath.CrossProduct(tmp, d); // 回転軸
if (normal.Length < 0.0001)
{
normal = new Vector3d(0, 0, 1);
}
else
{
normal = normal.UnitVector();
normal = CadMath.Normal(tmp, d);
}
CadQuaternion q = CadQuaternion.RotateQuaternion(normal, -angle);
CadQuaternion r = q.Conjugate();
ArrowHead a;
if (pos == ArrowPos.END || pos == ArrowPos.START_END)
{
a = ArrowHead.Create(type, ArrowPos.END, len, width);
a.Rotate(q, r);
a += pt1;
DrawLine(pen, a.p0.vector, a.p1.vector);
DrawLine(pen, a.p0.vector, a.p2.vector);
DrawLine(pen, a.p0.vector, a.p3.vector);
DrawLine(pen, a.p0.vector, a.p4.vector);
}
if (pos == ArrowPos.START || pos == ArrowPos.START_END)
{
a = ArrowHead.Create(type, ArrowPos.START, len, width);
a.Rotate(q, r);
a += pt0;
DrawLine(pen, a.p0.vector, a.p1.vector);
DrawLine(pen, a.p0.vector, a.p2.vector);
DrawLine(pen, a.p0.vector, a.p3.vector);
DrawLine(pen, a.p0.vector, a.p4.vector);
}
}
public static extern Arrow orig_Create(ArrowTypes type, LevelEntity owner, Vector2 position, float direction, int?overrideCharacterIndex = null, int?overridePlayerIndex = null);
private void DrawArrowRaw(DrawPen pen, Vector3d pt0, Vector3d pt1, ArrowTypes type, ArrowPos pos, double len, double width)
{
DrawUtil.DrawArrow(DrawLineRaw, pen, pt0, pt1, type, pos, len, width);
}
public Player FinishReviving()
{
Vector2 zero = Vector2.Zero;
Player result;
if (this.Corpse.Squished == Vector2.Zero && this.CanReviveAtThisPosition(ref zero))
{
PlayerInventory inventory = new PlayerInventory(false, false, false, false, new ArrowList(this.Corpse.Arrows));
// this.Corpse.Arrows.Clear (); // I don't know what this line does, but it was causing an accessibility exception
if (this.Corpse.ArrowCushion.Count > 0)
{
Arrow arrow = this.Corpse.ArrowCushion.ArrowDatas [0].Arrow;
if (inventory.Arrows.CanAddArrow(arrow.ArrowType) && arrow.Scene != null && !arrow.MarkedForRemoval)
{
base.Level.Remove <Arrow> (arrow);
inventory.Arrows.AddArrows(new ArrowTypes[] {
arrow.ArrowType
});
}
this.Corpse.ArrowCushion.ReleaseArrows(Vector2.UnitY * -1f);
}
if (this.Mode == TeamReviver.Modes.Quest && inventory.Arrows.Count == 0)
{
ArrowList arg_153_0 = inventory.Arrows;
ArrowTypes[] arrows = new ArrowTypes[1];
arg_153_0.AddArrows(arrows);
}
Vector2 position = zero;
Player player = new Player(this.Corpse.PlayerIndex, position, this.Corpse.Allegiance, this.Corpse.TeamColor, inventory, Player.HatStates.NoHat, true, false, false);
if (this.Mode == TeamReviver.Modes.TeamDeathmatch)
{
player.Flash(45, null);
}
else
{
player.Flash(135, null);
}
base.Level.Add <Player> (player);
//if (((MyMatchVariants)base.Level.Session.MatchSettings.Variants).GottaBustGhosts) {
// ((MySession)base.Level.Session).OnTeamRevive(player);
//}
int playerIndex = this.reviver;
if (playerIndex == -1)
{
playerIndex = player.PlayerIndex;
}
if (this.Mode == TeamReviver.Modes.DarkWorld)
{
Player player2 = base.Level.GetPlayer(this.reviver);
if (player2 != null)
{
player2.Flash(60, null);
}
}
ShockCircle shockCircle = Cache.Create <ShockCircle> ();
shockCircle.Init(position, playerIndex, player, ShockCircle.ShockTypes.TeamRevive);
base.Level.Add <ShockCircle> (shockCircle);
int num = Calc.Random.Next(360);
for (int i = num; i < num + 360; i += 30)
{
base.Level.Add <BombParticle> (new BombParticle(position, (float)i, BombParticle.Type.TeamRevive));
}
TFGame.PlayerInputs [this.Corpse.PlayerIndex].Rumble(1f, 30);
if (this.reviver != -1)
{
TFGame.PlayerInputs [this.reviver].Rumble(0.5f, 30);
}
if (this.reviver != -1)
{
MatchStats[] expr_2FA_cp_0 = base.Level.Session.MatchStats;
int expr_2FA_cp_1 = this.reviver;
expr_2FA_cp_0 [expr_2FA_cp_1].Revives = expr_2FA_cp_0 [expr_2FA_cp_1].Revives + 1u;
if (base.Level.Session.DarkWorldState != null)
{
base.Level.Session.DarkWorldState.Revives [this.reviver]++;
}
}
this.reviveCounter = 0f;
if (this.Corpse.TeamColor == Allegiance.Red)
{
Sounds.sfx_reviveRedteamFinish.Play(210f, 1f);
}
else
{
Sounds.sfx_reviveBlueteamFinish.Play(210f, 1f);
}
result = player;
}
else
{
result = null;
}
// If ghost revives is on, then a revive can cancel a level ending
if (this.ghostRevives && base.Level.Session.MatchSettings.Mode == Modes.TeamDeathmatch)
{
Allegiance allegiance;
if (!base.Level.Session.RoundLogic.TeamCheckForRoundOver(out allegiance))
{
base.Level.Session.CurrentLevel.Ending = false;
}
}
return(result);
}
