private static CharacterTemplate GetCharacterClass(CharacterEnum characterEnum)
{
switch (characterEnum)
{
case CharacterEnum.YourAdvisor:
return(new YourAdvisor());
case CharacterEnum.LordByron:
return(new LordByron());
case CharacterEnum.LordMontesque:
return(new LordMontesque());
case CharacterEnum.ViscountPhilip:
return(new ViscountPhilip());
case CharacterEnum.LadyMcKrombles:
return(new LadyMcKrombles());
case CharacterEnum.LordKevin:
return(new LordKevin());
default:
throw new UnityException("WRONG");
}
}
public void RefreshGameInfo()
{
player1type = PlayerTypeEnum.None;
player2type = PlayerTypeEnum.None;
player3type = PlayerTypeEnum.None;
player4type = PlayerTypeEnum.None;
player1char = CharacterEnum.None;
player2char = CharacterEnum.None;
player3char = CharacterEnum.None;
player4char = CharacterEnum.None;
player1score = -1;
player2score = -1;
player3score = -1;
player4score = -1;
player1lifes = -1;
player2lifes = -1;
player3lifes = -1;
player4lifes = -1;
player1deaths = -1;
player2deaths = -1;
player3deaths = -1;
player4deaths = -1;
}
/// <summary>
/// Handles a player death
/// Takes care of notifying everyone
/// </summary>
/// <param name="killer"></param>
/// <param name="deadChar"></param>
public void KillPlayer(CharacterEnum killer, CharacterEnum deadChar)
{
List <Card> drawnCards = new List <Card>();
if (killer != CharacterEnum.AMARU)
{
if (deadChar == CharacterEnum.AMARU)
{
UserDict[killer].Player.IsImmune = true;
drawnCards.Add(UserDict[killer].Player.Draw());
}
drawnCards.Add(UserDict[killer].Player.Draw());
}
KillPlayer4Turn(deadChar);
UserDict[ActiveCharacter].Write(new ResponseMessage(new PlayerKilledResponse(killer, deadChar, UserDict[killer].Player.IsImmune, drawnCards)));
foreach (CharacterEnum target in CharacterManager.Instance.Others(ActiveCharacter))
{
UserDict[target].Write(new ResponseMessage(new PlayerKilledResponse(killer, deadChar, UserDict[killer].Player.IsImmune, drawnCards.Count)));
}
if (Simulator)
{
return;
}
if (_turnList.Count == 1)
{
foreach (CharacterEnum target in UserDict.Keys)
{
UserDict[target].Write(new ResponseMessage(new GameFinishedResponse(_turnList[0])));
}
}
}
public MoveCreatureResponse(CharacterEnum caller, CreatureCard creature, Place place, int tablePos)
{
this.Caller = caller;
this.Creature = creature;
this.Place = place;
this.TablePos = tablePos;
}
public UseAbilityAction(CharacterEnum caller, int playedCardId, Target target) : base(caller, playedCardId)
{
this.Targets = new List <Target>()
{
target
};
}
public void RefreshGameInfo()
{
player1type = PlayerTypeEnum.None;
player2type = PlayerTypeEnum.None;
player3type = PlayerTypeEnum.None;
player4type = PlayerTypeEnum.None;
player1char = CharacterEnum.None;
player2char = CharacterEnum.None;
player3char = CharacterEnum.None;
player4char = CharacterEnum.None;
player1score = -1;
player2score = -1;
player3score = -1;
player4score = -1;
player1lifes = -1;
player2lifes = -1;
player3lifes = -1;
player4lifes = -1;
player1deaths = -1;
player2deaths = -1;
player3deaths = -1;
player4deaths = -1;
}
public AttackPlayerResponse(CharacterEnum caller, CharacterEnum target, CreatureCard attacker, int targetHealthAfter)
{
this.Caller = caller;
this.Target = target;
this.Attacker = attacker;
this.TargetHealthAfter = targetHealthAfter;
}
public PlayerModifiedResponse(CharacterEnum character, int newMana, int newHealth)
{
Modifieds = new List <PlayerMod>()
{
new PlayerMod(character, newMana, newHealth)
};
}
public Character(EntityDrawData drawData, string assetName, CharacterEnum cha)
: base(drawData, assetName)
{
_assetName = assetName;
_cha = cha;
_position = Position(_cha);
}
public static GameObject Spawn(CharacterEnum m_Player)
{
GameManager myManager = GameObject.Find("_GameManager").GetComponent<GameManager>();
Vector3 spawnLocation = Vector3.zero;
Quaternion rotation;
if(playerCount == 0){
spawnLocation = spawnLocations[0];
rotation = Quaternion.identity;
}
else
{
spawnLocation = spawnLocations[1];
rotation = Quaternion.Euler(0, 180, 0);
}
playerCount++;
switch(m_Player){
case CharacterEnum.Blue:
return MonoBehaviour.Instantiate(myManager.playerPrefabs[0], spawnLocation , rotation)as GameObject;
case CharacterEnum.Green:
return MonoBehaviour.Instantiate(myManager.playerPrefabs[1], spawnLocation , rotation) as GameObject;
case CharacterEnum.Red:
return MonoBehaviour.Instantiate(myManager.playerPrefabs[2], spawnLocation , rotation)as GameObject;
case CharacterEnum.Yellow:
return MonoBehaviour.Instantiate(myManager.playerPrefabs[3], spawnLocation , rotation)as GameObject;
default:
return new GameObject();
}
}
public PlayerKilledResponse(CharacterEnum killer, CharacterEnum dead, bool getsImmunity, int drawnCardsNum)
{
this.Killer = killer;
this.Dead = dead;
this.GetsImmunity = getsImmunity;
this.DrawnCardsNum = drawnCardsNum;
}
public AttackCreatureResponse(CharacterEnum caller, CharacterEnum target, CreatureCard attacker, CreatureCard attackedCreature)
{
this.Caller = caller;
this.Target = target;
this.Attacker = attacker;
this.AttackedCreature = attackedCreature;
}
public Weapon(EntityDrawData drawData, DirectionEnum direction, string assetName, CharacterEnum cha)
: base(drawData, assetName)
{
_assetName = assetName;
_direction = direction;
_cha = cha;
}
public static Azul.Rect[] GetRects(CharacterEnum typeIn)
{
Azul.Rect[] arrayOut = new Azul.Rect[2];
switch (typeIn)
{
case CharacterEnum.octopus:
arrayOut[0] = GetRect(RectType.Octopus1);
arrayOut[1] = GetRect(RectType.Octopus2);
break;
case CharacterEnum.crab:
arrayOut[0] = GetRect(RectType.Crab1);
arrayOut[1] = GetRect(RectType.Crab2);
break;
case CharacterEnum.squid:
arrayOut[0] = GetRect(RectType.Squid1);
arrayOut[1] = GetRect(RectType.Squid2);
break;
case CharacterEnum.corecannon:
arrayOut[0] = GetRect(RectType.CoreCannon1);
break;
case CharacterEnum.missle:
arrayOut = GetCCMissles();
break;
default:
break;
}
return(arrayOut);
}
public void SendResponse(CharacterEnum Dest, Response response)
{
if (Dest == CharacterEnum.AMARU)
{
return;
}
UserDict[Dest].Write(new ResponseMessage(response));
}
public EvocationResponse(CharacterEnum caller, CreatureCard original, CreatureCard evoked, Place destination, bool deleteOriginal = false)
{
this.Caller = caller;
this.Original = original;
this.Evoked = evoked;
this.Destination = destination;
this.DeleteOriginal = deleteOriginal;
}
public PlayerKilledResponse(CharacterEnum killer, CharacterEnum dead, bool getsImmunity, List <Card> drawnCards)
{
this.Killer = killer;
this.Dead = dead;
this.GetsImmunity = getsImmunity;
this.DrawnCards = drawnCards;
this.DrawnCardsNum = DrawnCards.Count;
}
public void init(CharacterEnum alienType = CharacterEnum.crab)
{
int xCordinate = GameSpecs.ScreenWidth / 2;
int yCordinate = GameSpecs.ScreenHeight / 2;
states = RectFactory.GetRects(alienType);
sprite = SpriteFactory.GetSprite(states[0], xCordinate, yCordinate);
Debug.Assert(sprite != null);
}
public NewTurnResponse(int currentRound, CharacterEnum activePlayer, int newMana, bool hasDrawn, List <Card> modifiedCards, int damage = 0)
{
this.CurrentRound = currentRound;
this.ActivePlayer = activePlayer;
this.NewMana = newMana;
this.HasDrawn = hasDrawn;
this.Damage = damage;
this.ModifiedCards = modifiedCards;
}
public Character(CharacterEnum name, int level, int addtional_health, int speed, int atk, string leader_skill_info)
{
this.name = name;
this.level = level;
this.addtional_health = addtional_health;
this.speed = speed;
this.atk = atk;
this.leader_skill_info = leader_skill_info;
}
public NewTurnResponse(int currentRound, CharacterEnum activePlayer, int newMana, Card drawnCard, List <Card> modifiedCards, int damage = 0)
{
this.CurrentRound = currentRound;
this.ActivePlayer = activePlayer;
this.NewMana = newMana;
this.DrawnCard = drawnCard;
this.HasDrawn = DrawnCard != null;
this.ModifiedCards = modifiedCards;
this.Damage = damage;
}
public GameObject GetPrefab(CharacterEnum id)
{
CharacterConfig config = CharacterConfigs.FirstOrDefault(x => x.Id == id);
if (config == null)
{
throw new NullReferenceException($"No Character config for id: {nameof(id)}");
}
return(config.Prefab);
}
public void X(int i, bool overrideNow = false)
{
if (i == (int)CharacterEnum.Player)
{
if (!overrideNow && playerNumber > ((MultiplayerManager.nlm.numPlayers) * 2))
{
i = NumberTools.Loop(i + 1, 3, 1);
}
}
CharE = (CharacterEnum)i;
}
public Character(CharacterMovement characterMovement, CharacterHighlight characterHighlight, GameObject characterActor, CharacterAttributes characterAttributes, CharacterEnum type, int team)
{
CharacterActor = characterActor;
CharacterHighlight = characterHighlight;
CharacterMovement = characterMovement;
CharacterAttributes = characterAttributes;
CharacterMovement.IsSelected = () => CharacterHighlight.State == CharacterHighlightEnum.Selected;
CharacterMovement.attributes = CharacterAttributes;
Type = type;
Team = team;
}
public void _CreateOption()
{
var characterEnum = Enum.GetNames(typeof(CharacterEnum));
foreach (var item in characterEnum)
{
CharacterPf tmp = Instantiate(m_CharacterPf, m_pfParent);
CharacterEnum tmpEnum = (CharacterEnum)Enum.Parse(typeof(CharacterEnum), item, true);
tmp._SetupData(m_characterChose.m_TextureDic[tmpEnum], 0, m_characterChose, this);
}
}
public BaseCharacter SpawnCharacter(CharacterEnum type, bool endgame)
{
GameObject go = Instantiate(CharacterFactory.GetPrefab(type));
go.transform.SetParent(GameObject.Find("Environment/Map/Entities").transform, false);
go.transform.position = Building.transform.position;
var character = go.GetComponent <BaseCharacter>();
character?.Setup(Building, endgame);
return(character);
}
public override void Visit(PropertyVisitor visitor, CharacterEnum character, CardProperty property = null)
{
if (property != null)
{
base.Visit(visitor, character, property);
}
else
{
base.Visit(visitor, character, Effect);
}
}
private void CreateCharacter(Slot slot, CharacterEnum type)
{
BaseCharacter newChar = slot.SpawnCharacter(type, houseSpawnedCounter >= 12);
newChar.CharacterUpseted += OnCharacterUpseted;
newChar.InterestReached += OnCharacterInterestReached;
CharacterSpawned?.Invoke(this, new CharacterSpawnedArgs {
Character = newChar
});
Score += 5;
}
private Span[] TokenizeToSpans(string input)
{
CharacterEnum charType = CharacterEnum.Whitespace;
CharacterEnum state = charType;
List <Span> tokens = new List <Span>();
int inputLength = input.Length;
int start = -1;
char previousChar = (char)(0);
for (int characterIndex = 0; characterIndex < inputLength; characterIndex++)
{
char c = input[characterIndex];
if (System.Char.IsWhiteSpace(c))
{
charType = CharacterEnum.Whitespace;
}
else if (System.Char.IsLetter(c))
{
charType = CharacterEnum.Alphabetic;
}
else if (System.Char.IsDigit(c))
{
charType = CharacterEnum.Numeric;
}
else
{
charType = CharacterEnum.Other;
}
if (state == CharacterEnum.Whitespace)
{
if (charType != CharacterEnum.Whitespace)
{
start = characterIndex;
}
}
else
{
if (charType != state || (charType == CharacterEnum.Other && c != previousChar))
{
tokens.Add(new Span(start, characterIndex));
start = characterIndex;
}
}
state = charType;
previousChar = c;
}
if (charType != CharacterEnum.Whitespace)
{
tokens.Add(new Span(start, inputLength));
}
return(tokens.ToArray());
}
// Use this for initialization
void Start()
{
Physics.queriesHitTriggers = true;
t = GetComponent <Text> ();
if (Manager.playerAIFalseCount != null && (Manager.playerAIFalseCount.Length >= playerNumber))
{
CharE = (Manager.playerAIFalseCount [playerNumber - 1] == true) ? CharacterEnum.AI : CharacterEnum.Player;
}
else
{
CharE = CharacterEnum.Off;
}
}
public void CharacterChanging(CharacterEnum cha)
{
//choosing stuff
switch (cha)
{
case CharacterEnum.CuteGenji:
_assetName = "genji1";
_assetNameHurt = "genji1Dead";
_assetNameDead = "genji1deaddead";
break;
case CharacterEnum.EvilGenji:
_assetName = "genji2";
_assetNameHurt = "genji2Dead";
_assetNameDead = "genji2deaddead";
break;
case CharacterEnum.PixelGenji:
_assetName = "genji3";
_assetNameHurt = "genji3Dead";
_assetNameDead = "genji3deaddead";
break;
case CharacterEnum.Reinhardt:
_assetName = "reinhardt";
_assetNameHurt = "reinhardtDead";
_assetNameDead = "reinhardtdeaddead";
break;
case CharacterEnum.Torbjorn:
_assetName = "torbjorn";
_assetNameHurt = "torbjornDead";
_assetNameDead = "torbjorndeaddead";
break;
case CharacterEnum.Mercy:
_assetName = "mercy";
_assetNameHurt = "mercyDead";
_assetNameDead = "mercydeaddead";
break;
default:
_assetName = "mercy";
_assetNameHurt = "mercyDead";
_assetNameDead = "mercydeaddead";
break;
}
_characterChanged = true;
Console.WriteLine(_assetName);
}
public static void AssignCharacter(ref Character MyCharacter, CharacterEnum character, Player player)
{
switch (character)
{
case CharacterEnum.Sylvia:
MyCharacter = new Sylvia(player);
player.GetModPlayer <SylviaPlayer>().IsSylvia = true;
break;
default:
Main.NewText("Invalid Character: AssignCharacter");
break;
}
}
public WeaponPistol(CharacterEnum type)
{
base.damage = 25;
base.weaponType = WeaponEnum.pistol;
base.ammo = 5;
base.maxAmmo = 5;
base.reloadTime = 2f;
base.readyToFire = true;
bulletSpeed = 1.1f;
switch (type)
{
case (CharacterEnum.Tesla):
base.sprite = "Sprites/Weapons/teslaPistol"; base.bulletAnimControler = "Animations/bullets_animators/bullet_tesla_animator";
base.setUpSounds("teslaPistol");
break;
case (CharacterEnum.Nobel):
base.sprite = "Sprites/Weapons/nobelPistol"; base.bulletAnimControler = "Animations/bullets_animators/bullet_nobel_animator";
base.setUpSounds("nobelPistol");
break;
case (CharacterEnum.Einstein):
base.sprite = "Sprites/Weapons/einsteinPistol"; base.bulletAnimControler = "Animations/bullets_animators/bullet_einstein_animator";
base.setUpSounds("einsteinPistol");
break;
case (CharacterEnum.Curie):
base.sprite = "Sprites/Weapons/curiePistol"; base.bulletAnimControler = "Animations/bullets_animators/bullet_curie_animator";
base.setUpSounds("curiePistol");
break;
case (CharacterEnum.DaVinci):
base.sprite = "Sprites/Weapons/davinciPistol"; base.bulletAnimControler = "Animations/bullets_animators/bullet_davinci_animator";
base.setUpSounds("davinciPistol");
break;
}
kadency = 0.1f;
kadReady = true;
loadSprites(sprite, bulletAnimControler);
}
public void SetUpPlayer(int playerNumber, CharacterEnum charEnum)
{
if (playerNumber < 1 || playerNumber > 4) return;
switch (playerNumber)
{
case 1:
player1Info.playerNumber = 1;
player1Info.charEnum = charEnum;
player1Info.playerColor = "red";
player1Info.lifes = gameInfo.lifes;
switch (gameInfo.player1type)
{
case PlayerTypeEnum.Player:
player1Comp.SetUpPlayer(player1Info, new ControlKeysP1());
GameObject.Find("player_info_red").GetComponent<HUDBase>().SetUp(player1Comp);
player1Active = true;
break;
case PlayerTypeEnum.AI:
ai1Comp.SetUpPlayer(player1Info);
GameObject.Find("player_info_red").GetComponent<HUDBase>().SetUp(ai1Comp);
player1Active = true;
break;
case PlayerTypeEnum.None:
player1Active = false;
break;
}
break;
case 2:
player2Info.playerNumber = 2;
player2Info.charEnum = charEnum;
player2Info.playerColor = "green";
player2Info.lifes = gameInfo.lifes;
switch (gameInfo.player2type)
{
case PlayerTypeEnum.Player:
player2Comp.SetUpPlayer(player2Info, new ControlKeysP2());
GameObject.Find("player_info_green").GetComponent<HUDBase>().SetUp(player2Comp); ;
player2Active = true;
break;
case PlayerTypeEnum.AI:
ai2Comp.SetUpPlayer(player2Info);
GameObject.Find("player_info_green").GetComponent<HUDBase>().SetUp(ai2Comp);
player2Active = true;
break;
case PlayerTypeEnum.None:
player2Active = false;
break;
}
break;
case 3:
player3Info.playerNumber = 3;
player3Info.charEnum = charEnum;
player3Info.playerColor = "blue";
player3Info.lifes = gameInfo.lifes;
switch (gameInfo.player3type)
{
case PlayerTypeEnum.Player:
player3Comp.SetUpPlayer(player3Info, new ControlKeysP3());
GameObject.Find("player_info_blue").GetComponent<HUDBase>().SetUp(player3Comp);
player3Active = true;
break;
case PlayerTypeEnum.AI:
ai3Comp.SetUpPlayer(player3Info);
GameObject.Find("player_info_blue").GetComponent<HUDBase>().SetUp(ai3Comp);
player3Active = true;
break;
case PlayerTypeEnum.None:
player3Active = false;
break;
}
break;
case 4:
player4Info.playerNumber = 4;
player4Info.charEnum = charEnum;
player4Info.playerColor = "yellow";
player4Info.lifes = gameInfo.lifes;
switch (gameInfo.player4type)
{
case PlayerTypeEnum.Player:
player4Comp.SetUpPlayer(player4Info, new ControlKeysP4());
GameObject.Find("player_info_yellow").GetComponent<HUDBase>().SetUp(player4Comp);
player4Active = true;
break;
case PlayerTypeEnum.AI:
ai4Comp.SetUpPlayer(player4Info);
GameObject.Find("player_info_yellow").GetComponent<HUDBase>().SetUp(ai4Comp);
player4Active = true;
break;
case PlayerTypeEnum.None:
player4Active = false;
break;
}
break;
}
}
public PlayerData(int PlayerNumber,CharacterEnum targetChar,bool isControllable, PlayerBase PlayerInformation)
{
this.playerNumber = PlayerNumber;
this.targetCharacter = targetChar;
this.Controllable = isControllable;
this.playerInformation = PlayerInformation;
}
public void InsertNPC(CharacterEnum character, PlayerBase targetplayer)
{
Players.Add(new PlayerData(Players.Count, character,false,targetplayer));
}
public void SetUpPlayer(int playerNumber, CharacterEnum charEnum)
{
if (playerNumber < 1 || playerNumber > 4) return;
switch (playerNumber)
{
case 1:
player1Info.playerNumber = 1;
player1Info.charEnum = charEnum;
player1Info.playerColor = "red";
player1Info.lifes = gameInfo.lifes;
switch (gameInfo.player1type)
{
case PlayerTypeEnum.None:
player1Active = false;
break;
default:
ControlKeys ck = new ControlKeysP1();
ck.keyFire = KeyCode.None;
player1Comp.SetUpPlayer(player1Info, ck);
player1Active = true;
break;
}
break;
case 2:
player2Info.playerNumber = 2;
player2Info.charEnum = charEnum;
player2Info.playerColor = "green";
player2Info.lifes = gameInfo.lifes;
switch (gameInfo.player2type)
{
case PlayerTypeEnum.None:
player2Active = false;
break;
default:
ControlKeys ck = new ControlKeysP2();
ck.keyFire = KeyCode.None;
player2Comp.SetUpPlayer(player2Info, ck);
player2Active = true;
break;
}
break;
case 3:
player3Info.playerNumber = 3;
player3Info.charEnum = charEnum;
player3Info.playerColor = "blue";
player3Info.lifes = gameInfo.lifes;
switch (gameInfo.player3type)
{
case PlayerTypeEnum.None:
player3Active = false;
break;
default:
ControlKeys ck = new ControlKeysP3();
ck.keyFire = KeyCode.None;
player3Comp.SetUpPlayer(player3Info, ck);
player3Active = true;
break;
}
break;
case 4:
player4Info.playerNumber = 4;
player4Info.charEnum = charEnum;
player4Info.playerColor = "yellow";
player4Info.lifes = gameInfo.lifes;
switch (gameInfo.player4type)
{
case PlayerTypeEnum.None:
player4Active = false;
break;
default:
ControlKeys ck = new ControlKeysP4();
ck.keyFire = KeyCode.None;
player4Comp.SetUpPlayer(player4Info, ck);
player4Active = true;
break;
}
break;
}
}
