void Start()
{
characterManager = GameObject.Find ("CharacterManager");
characterManagerController = characterManager.GetComponent<CharacterManager> ();
body = transform.Find ("Body").gameObject;
gunMuzzle = GameObject.Find ("gunMuzzle").gameObject;
}
void AddClothes(CharacterManager characterManager, int id)
{
SavedSettings.PlayerSettings playerSettings = savedSettings.GetClothes(Data.Instance.settings.disciplinaId, id);
if (playerSettings != null)
{
print("AddClothes username: "******" " + playerSettings.username);
characterManager.SetCloth(clothesSettings.faces, playerSettings.face);
characterManager.SetCloth(clothesSettings.hairs, playerSettings.hair);
characterManager.SetCloth(clothesSettings.legs, playerSettings.bottom);
characterManager.SetCloth(clothesSettings.shoes, playerSettings.shoes);
characterManager.SetCloth(clothesSettings.tops, playerSettings.body);
characterManager.SetCloth(clothesSettings.glasses, playerSettings.glasses);
characterManager.SetColor(playerSettings.color);
GameObject newNameLabel = Instantiate(NameLabel);
newNameLabel.transform.SetParent(CharactersContainer.transform);
newNameLabel.transform.localPosition = characterManager.gameObject.transform.parent.localPosition;
newNameLabel.transform.localScale = Vector3.one;
newNameLabel.GetComponentInChildren<TextMesh>().text = playerSettings.username;
}
else
{
characterManager.gameObject.SetActive(false);
}
}
// Use this for initialization
void Start()
{
transform.position = new Vector3(-1.86f, 2.5f, 3.3f);
numCharacters = 0;
characters = new List<GameObject>();
instance = this;
}
public void LoadGame()
{
m_cardManager = new CardManager(cardFile);
m_mobManager = new MobManager(mobFile);
m_characterManager = new CharacterManager(characterFile);
Application.LoadLevel("game");
}
public static void Initialize()
{
Character = CharacterManager.GetInstance();
ClientDB = ClientDBManager.GetInstance();
GameAccount = GameAccountManager.GetInstance();
Redirect = RedirectManager.GetInstance();
}
void Start()
{
s_pInst = this;
m_pCharacManager = new CharacterManager(); // doesn't need to be singleton
m_pUIManager = new UIManager();
m_pUIManager.OnMenuOpenClose += m_pCharacManager.TogglePause;
}
void Setup()
{
manager = Chars.GetComponent<CharacterManager>();
NGUITools.SetActive(StatsTab, true);
NGUITools.SetActive(SkillsTab, false);
NGUITools.SetActive(InventoryTab, false);
}
public override bool Check () {
_targetManager = _database.GetData<CharacterManager> ("targetManager");
if (_targetManager == null)
return false;
Transform targetTrans = _targetManager.transform.Find("DownCollider");
return Mathf.Abs (_trans.position.x - targetTrans.position.x) < _equipmentStatus.Range.x &&
Mathf.Abs (_trans.position.y - targetTrans.position.y) < _equipmentStatus.Range.y;
}
public CreateCharacterViewModel()
{
Manager = new CharacterManager();
AvailableClasses = new List<PrestigeClass>(Manager.GetPrestigeClasses());
AvailableSpecies = new List<Species>(Manager.GetSpecies());
AvailableGenders = new List<Genders>(Manager.GetGenders());
}
void Awake()
{
Path = GetComponentInChildren<PathMaker>().Setup(this);
Charac = GetComponentInChildren<CharacterManager>().Setup(this);
Cam = Camera.main;
UI = FindObjectOfType<Canvas>();
changeLighting();
}
public void Init(GameObject manager)
{
cm = manager.GetComponent<CharacterManager>();
am = manager.GetComponent<AnnouncementManager>();
uim = GameObject.Find ("UserInterface").GetComponent<UserInterfaceManager>();
cas = GetComponentInChildren<CharacterSoundController>();
health = maximumHealth;
UpdateHealthToUI ();
}
// Use this for initialization
void Start () {
UpBodyTrans = character.transform.Find("UpBody");
DownColliderTrans = character.transform.Find("DownCollider");
playerStatus = PlayerStatus.InAir;
Distance = 1000;
characterManager = character.GetComponent<CharacterManager>();
characterManager.localEventManager.ChangeToAirEvent+= delegate {playerStatus = PlayerStatus.InAir;};
characterManager.localEventManager.ChangeToGroundEvent+= delegate {playerStatus = PlayerStatus.OnGround;};
}
public static void Initialize()
{
Character = CharacterManager.GetInstance();
ClientDB = ClientDBManager.GetInstance();
GameAccount = GameAccountManager.GetInstance();
Redirect = RedirectManager.GetInstance();
Session = SessionManager.GetInstance();
Player = PlayerManager.GetInstance();
Spawns = SpawnManager.GetInstance();
}
public static CharacterManager Instance()
{
if (instance == null) {
instance = (CharacterManager)FindObjectOfType(typeof(CharacterManager));
if (instance == null && !Application.isPlaying) {
instance = new GameObject("Character Manager").AddComponent<CharacterManager>();
}
}
return instance;
}
void Start()
{
characterManager = GameObject.Find ("CharacterManager");
characterManagerController = characterManager.GetComponent<CharacterManager> ();
player = characterManagerController.activePlayer ();
offset = new Vector3(positionX, positionY, positionZ);
mainCamera.transform.rotation = Quaternion.AngleAxis(rotate, Vector3.right);
if (player) mainCamera.transform.position = player.transform.position + offset;
}
void Awake() {
instance = this;
characterStatusList = new List<CharacterStatus>();
characters = new List<GameObject>();
activeCheckPoint = initialCheckPoint.GetComponent<CheckPoint>();
for (int i = 0 ; i < characterList.Count ; i++) {
characterStatusList.Add(characterList[i].GetComponent<CharacterStatus>());
characters.Add(characterList[i]);
}
activeCharacter = characterList[0];
}
public AllViewModel()
{
Manager = new CharacterManager();
CompanionManager = new CompanionManager();
OutfitManager = new OutfitManager();
Characters = Manager.GetCharacters();
if (Characters != null)
Character = Characters.FirstOrDefault();
AddFollowerCommand = new DelegateCommand(AddFollower);
}
// Called at game creation
void Awake()
{
if (s_Instance != null)
{
Debug.LogWarning("2 characters in scene, last removed");
GameObject.Destroy(gameObject);
}
else
{
s_Instance = this;
}
}
// Use this for initialization
void Start () {
// Screen.SetResolution(256, 240, false); // trying to set the right resolution from NES
minSwipeDist = 50.0f;
moving = false;
player = GameObject.Find("PlayerMcFly");
if(player ==null)
player = GameObject.Find("PlayerDoloreane"); //TODO ADD OTHER PLAYERS
if (player == null)
Debug.Log("LE JOUEUR N'EST PAS TROUVE");
characterManager = player.GetComponent<CharacterManager>();
invertedControls = false;
}
public static SlotItem[] GetItemsForCharacter(CharacterManager.ItemType type, int? characterId = null)
{
using (var bl = Storage.GetBuilder(CharacterManager.SQLSafeName))
{
bl.SelectFrom(TableName, new string[] { "*" },
new WhereFilter(ColumnNames.TypeId, (int)type),
new WhereFilter(ColumnNames.CharacterId, characterId)
);
return Storage.ExecuteArray<SlotItem>(bl);
}
}
public override bool Check () {
_targetManager = _database.GetData<CharacterManager> ("targetManager");
float alertTime = _database.GetData<float> (_alertTimeID);
if (alertTime > 0)
_database.SetData<float> (_alertTimeID, alertTime -= Time.deltaTime);
if (_targetManager == null)
return false;
if (_targetManager.characterBase.isDie == true)
return false;
_database.SetData<float>(_alertTimeID,5f);
return true;
}
public static int GetItem(CharacterManager.ItemType type, int slot, int? characterId = null)
{
using (var bl = Storage.GetBuilder(CharacterManager.SQLSafeName))
{
bl.SelectFrom(TableName, new string[] { ColumnNames.Id },
new WhereFilter(ColumnNames.TypeId, (int)type),
new WhereFilter(ColumnNames.Slot, slot),
new WhereFilter(ColumnNames.CharacterId, characterId)
);
return (int)Storage.ExecuteScalar<Int32>(bl);
}
}
// Use this for initialization
void Awake() {
if (characterManagerPrefab == null) {
characterManagerPrefab = GameObject.FindGameObjectWithTag("CharacterManager");
}
characterManager = characterManagerPrefab.GetComponent<CharacterManager>();
characterMovement = GetComponent<CharacterMovement>();
playerUse = GetComponent<PlayerUse>();
CharacterAnimationController.SetAnimatorReference(characterName, GetComponent<Animator>());
rigBody = GetComponent<Rigidbody>();
specialIdleController = GetComponent<SpecialIdleController>();
deadParticles = transform.Find("DeadParticles").gameObject.GetComponent<ParticlesActivator>();
resurrectionParticles = transform.Find("ResurrectionParticles").gameObject.GetComponent<ParticlesActivator>();
playerParticles = transform.Find("PlayerParticles").gameObject.GetComponent<ParticlesActivator>();
}
// Use this for initialization
void Start() {
currentState = GameState.START_SCREEN;
print("Now Playing...");
spawnerManager = gameObject.GetComponent<SpawnerManager>();
scoreManager = gameObject.GetComponent<ScoreManager>();
floorManager = gameObject.GetComponent<FloorScript>();
playerA = GameObject.FindGameObjectWithTag("PlayerA");
characterManagerA = playerA.GetComponent<CharacterManager>();
playerB = GameObject.FindGameObjectWithTag("PlayerB");
characterManagerB = playerB.GetComponent<CharacterManager>();
hud.enabled = false;
}
// Use this for initialization
void Start () {
cManager = new CharacterManager ();
enemy1Label = this.transform.Find("bg/WikiPanel/Enemy1/Enemy1Des").GetComponent<UILabel>();
enemy2Label = this.transform.Find("bg/WikiPanel/Enemy2/Enemy2Des").GetComponent<UILabel>();
enemy3Label = this.transform.Find("bg/WikiPanel/Enemy3/Enemy3Des").GetComponent<UILabel>();
enemy4Label = this.transform.Find("bg/WikiPanel/Enemy4/Enemy4Des").GetComponent<UILabel>();
enemy5Label = this.transform.Find("bg/WikiPanel/Enemy5/Enemy5Des").GetComponent<UILabel>();
enemy6Label = this.transform.Find("bg/WikiPanel/Enemy6/Enemy6Des").GetComponent<UILabel>();
enemy1Label.text = "HP: " + cManager.hpList [0] + "\n" + "ARMOR: " + cManager.armorList [0];
enemy2Label.text = "HP: " + cManager.hpList [1] + "\n" + "ARMOR: " + cManager.armorList [1];
enemy3Label.text = "HP: " + cManager.hpList [2] + "\n" + "ARMOR: " + cManager.armorList [2];
enemy4Label.text = "HP: " + cManager.hpList [3] + "\n" + "ARMOR: " + cManager.armorList [3];
enemy5Label.text = "HP: " + cManager.hpList [4] + "\n" + "ARMOR: " + cManager.armorList [4];
enemy6Label.text = "HP: " + cManager.hpList [5] + "\n" + "ARMOR: " + cManager.armorList [5];
}
public static int NewItem(CharacterManager.ItemType type, int netId, int stack, int prefix, bool favorite, int slot, int? characterId = null)
{
using (var bl = Storage.GetBuilder(CharacterManager.SQLSafeName))
{
bl.InsertInto(TableName,
new DataParameter(ColumnNames.TypeId, (int)type),
new DataParameter(ColumnNames.NetId, netId),
new DataParameter(ColumnNames.Stack, stack),
new DataParameter(ColumnNames.Prefix, prefix),
new DataParameter(ColumnNames.Slot, slot),
new DataParameter(ColumnNames.CharacterId, characterId),
new DataParameter(ColumnNames.Favorite, favorite)
);
return (int)Storage.ExecuteInsert(bl); //Get the new ID
}
}
void Awake( )
{
charMng = this;
Application.targetFrameRate = targetFrameRate;
PlayerData.GetInstance().LoadAll();
PlayerData.GetInstance().canMove = true;
GameCode.ClassName className = PlayerData.GetInstance().GetClassName();
player = (GameObject)PoolManager.GetInstance().GetPool(playerPrefabs[(int)className]).GetObject(playerOriginPosition);
SkillManager skillMng = player.GetComponent<SkillManager>();
for (int i = 0; i < PlayerData.GetInstance().hasLearned.Length; i++)
{
if (PlayerData.GetInstance().hasLearned[i])
{
skillMng.Learn(i);
}
}
}
public void InitializeInn(EventInfo info)
{
characters.Clear();
chars = level.characterManager;
m_info = info;
foreach(string name in m_info.mobs) {
CharacterInfo c = chars.GetCharacterByName(name);
if(c != null) {
Debug.Log("Found character named: " + name);
characters.Add(c);
}
}
for(int i = 0; i < 3; i++) {
slots[i].ToggleSlot(false);
}
for(int i = 0; i < characters.Count && i < 3; i++) {
slots[i].InitializeSlot(characters[i]);
}
}
void Awake() {
cm = this;
original_baseSpeedStandard = baseSpeedStandard;
original_boosterPlusSpeedStandard = boosterPlusSpeedStandard;
original_boosterMaxSpeedStandard = boosterMaxSpeedStandard;
original_boosterSpeedDecreaseStandard = boosterSpeedDecreaseStandard;
original_energyReduceOnTimeStandard = energyReduceOnTimeStandard;
original_energyReduceOnTimeStandard_hard = energyReduceOnTimeStandard_hard;
original_maxEnergyStandard = maxEnergyStandard;
original_reboundTimeScaleStandard = reboundTimeScaleStandard;
original_damageGetScaleStandard = damageGetScaleStandard;
characterNames = new List<string>();
Transform characters = transform.Find("Characters");
for (int i = 0; i < characters.childCount; i++) {
characterNames.Add(characters.GetChild(i).name);
}
randomList = new List<string>();
}
// Use this for initialization
void Awake ()
{
main = this;
charaList = new List<CharaMove>();
//初期キャラクター作成
for( int i = 0 ; i < CHARA_MAX ; i++)
{
CharaMove data = Instantiate( OriginalChara );
data.transform.parent = transform;
data.transform.localScale = new Vector3(1,1,1);
data.transform.localPosition = Vector3.zero;
data.gameObject.SetActive( false );
charaList.Add(data);
}
DateTime currentDate = DateTime.Now;
}
// handle the selected option
void HandleSelectedOption()
{
switch (activeElement)
{
case 0:
CharacterManager.GetInstance().numberOfUsers = 1;
break;
case 1:
CharacterManager.GetInstance().numberOfUsers = 2;
CharacterManager.GetInstance().players[1].playerType = PlayerBase.PlayerType.user;
break;
case 2:
nextScene = "Credits";
break;
default:
Debug.Log("No valid option from menu");
break;
}
}
protected override void Update(GameTime gameTime)
{
if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape))
{
Exit();
}
var keyState = Keyboard.GetState();
if (keyState.GetPressedKeys().Any(a => a == Keys.Up || a == Keys.Down || a == Keys.Left || a == Keys.Right))
{
CharacterManager.MoveMainCharacter(keyState.GetPressedKeys().ToList(), gameTime, _graphics);
}
CharacterManager.Hit(keyState);
EnemyManager.MoveEnemies(gameTime);
GameManager.Render.GameTime = gameTime;
base.Update(gameTime);
}
private void MessageReceived(IDictionary <string, object> command, bool isAd)
{
var character = command.Get(Constants.Arguments.Character);
var message = command.Get(Constants.Arguments.Message);
var channel = command.Get(Constants.Arguments.Channel);
// dedupe logic
if (isAd && automation.IsDuplicateAd(character, message))
{
return;
}
if (ApplicationSettings.GlobalPruningTermsList.Any(x => message.ContainsOrdinal(x)))
{
return;
}
if (!CharacterManager.IsOnList(character, ListKind.Ignored))
{
channels.AddMessage(message, channel, character, isAd ? MessageType.Ad : MessageType.Normal);
}
}
// Triggered when a collision happens.
protected override void OnTriggerEnter2D(Collider2D other)
{
CharacterManager attacker = GameplayManager.Instance.attackersDict[gameObject.GetInstanceID()];
CharacterManager defender = other.GetComponent <CharacterManager>() as CharacterManager;
/*
* if (other.tag == "wall" || other.tag == "door")
* {
* gameObject.SetActive(false);
* }
* else*/
if (
(attacker.tag == "Player" && other.tag == "Enemy") ||
(attacker.tag == "Enemy" && other.tag == "Player") ||
(attacker.tag == "Player" && other.tag == "Boss") ||
(attacker.tag == "Boss" && other.tag == "Player")
)
{
GameplayManager.Instance.ExecuteAttack(attacker, defender);
//gameObject.SetActive(false);
}
}
void Start()
{
Debug.Log("turn order manager");
findCharacters = FindObjectsOfType <CharacterManager>();
findPlayerAllies = GameObject.FindGameObjectsWithTag("Player Ally");
Debug.Log("player length found is " + findPlayerAllies.Length);
// add player allies found to List
for (int i = 0; i < findPlayerAllies.Length; i++)
{
playerAllies.Add(findPlayerAllies[i].GetComponent <CharacterManager>());
}
Debug.Log("player count is " + playerAllies.Count);
findEnemyAllies = GameObject.FindGameObjectsWithTag("Enemy Ally");
Debug.Log("enemy length found is " + findEnemyAllies.Length);
// add enemy allies found to List
for (int i = 0; i < findEnemyAllies.Length; i++)
{
enemyAllies.Add(findEnemyAllies[i].GetComponent <CharacterManager>());
}
Debug.Log("enemy count is " + enemyAllies.Count);
for (int i = 0; i < findCharacters.Length; i++)
{
Debug.Log("number " + i + " is " + findCharacters[i]);
charactersInBattle.Add(findCharacters[i]);
Debug.Log("characters in battle are " + charactersInBattle[i]);
}
Debug.Log("total number of characters found is " + charactersInBattle.Count);
int characterTurnFirst = Mathf.RoundToInt(Random.Range(0, charactersInBattle.Count));
Debug.Log("random number is " + characterTurnFirst);
currentTurn = charactersInBattle[characterTurnFirst];
currentTurnPosition = characterTurnFirst;
StartTurn();
}
// function for setting which fighter object is instanciated into scene to display selected fighter
void HandleCharacterPreview(PlayerInterfaces pl)
{
if (pl.previewPotrait != pl.activePotrait)
{
if (pl.createdCharacter != null)
{
Destroy(pl.createdCharacter);
}
audioManager.soundPlay("Effect_Click");
GameObject go = Instantiate(
CharacterManager.getInstance().returnCharacterWithId(pl.activePotrait.characterId).prefab, pl.charVisPos.position, Quaternion.identity) as GameObject;
pl.createdCharacter = go;
pl.previewPotrait = pl.activePotrait;
if (!string.Equals(pl.playerBase.playerId, charManager.players[0].playerId))
{
pl.createdCharacter.GetComponent <StateManager>().lookRight = false;
}
}
}
//----------------------
//PRIVATE METHODS
//----------------------
//When the manager first gets created
void Awake()
{
DontDestroyOnLoad(gameObject);
//Create the manager instances
Instance = this;
UIManagerInstance = new UIManager();
CharManagerInstance = new CharacterManager();
LevelManagerInstance = new LevelManager();
//Create the inventory
CharacterInventory = new Inventory();
//Initialize the character stats
CharManagerInstance.InitializeCharacterStats();
//Initialize the inventory
CharacterInventory.Initialize();
//Load the first level
LevelManagerInstance.LoadLevel(1);
}
public static void On_WorldClient_AcademyMemberJoined(WorldConnector pConnector, InterPacket pPacket)
{
int guildID, characterID;
DateTime registerDate;
if (!pPacket.TryReadInt(out guildID) ||
!pPacket.TryReadInt(out characterID) ||
!pPacket.TryReadDateTime(out registerDate))
{
return;
}
Guild guild;
if (GuildManager.GetGuildByID(guildID, out guild))
{
var member = new GuildAcademyMember(guild.Academy, characterID, GuildAcademyRank.Member, registerDate)
{
IsOnline = true,
};
guild.Academy.Members.Add(member);
ZoneCharacter character;
if (CharacterManager.GetLoggedInCharacter(characterID, out character))
{
member.Character = character;
character.Guild = guild;
character.GuildAcademy = guild.Academy;
character.GuildAcademyMember = member;
GuildManager.SetGuildBuff(character);
}
}
}
public void AddTemporaryHpWithLessDoesNotReplacesExisting()
{
int oldTempHp = 4;
int newTempHp = 3;
Character character = new Character()
{
TempHp = oldTempHp
};
TempHp tempHp = new TempHp()
{
Hp = newTempHp
};
var mockDal = new Mock <ICharacterData>();
CharacterManager characterManager = new CharacterManager(mockDal.Object);
mockDal.Setup(dal => dal.UpdateCharacter(character)).Returns(character);
Character updatedCharacter = characterManager.AddTemporaryHp(character, tempHp);
Assert.Equal(oldTempHp, updatedCharacter.TempHp);
}
private void WriteInTypeFile(Log log)
{
switch (this.Type)
{
case FileAppenderType.JSON:
JsonManager.WriteToJsonFile <Log>(Path, Name, log);
break;
case FileAppenderType.YAML:
YamlManager.WriteToYamlFile <Log>(Path, Name, log);
break;
case FileAppenderType.XML:
XmlManager.WriteToXmlFile <Log>(Path, Name, log);
break;
case FileAppenderType.CSV:
CsvManager.WriteToCsvFile <Log>(Path, Name, log);
break;
case FileAppenderType.BINARY:
BinaryManager.WriteToBinaryFile <Log>(Path, Name, log);
break;
case FileAppenderType.CHARACTER:
CharacterManager.WriteToCharacterFile <Log>(Path, Name, log);
break;
case FileAppenderType.TEXT:
default:
this.WriteToTxtFile(log);
break;
}
}
public void SetHUDPreview(CharacterManager characterAttack, CharacterManager characterDefense, bool range)
{
this.characterAttack = characterAttack;
this.characterDefense = characterDefense;
this.rangeAttack = range;
spriteLeft.sprite = characterAttack._spritePreview;
nameUnitLeft.text = characterAttack._character._name;
hitRateLeft.text = GetDodge(characterDefense, characterAttack);
leftSliderHealthAfter.maxValue = leftSliderCurrentHealth.maxValue = characterAttack.m_lifeManager.MaxHealth;
leftSliderCurrentHealth.value = characterAttack.m_lifeManager.Health;
leftSliderHealthAfter.value = characterDefense.hasAttacked ? characterAttack.m_lifeManager.Health - 0 : characterAttack.m_lifeManager.Health - GetDamage(characterAttack, characterDefense);
spriteRight.sprite = characterDefense._spritePreview;
nameUnitRight.text = characterDefense._character._name;
hitRateRight.text = GetDodge(characterAttack, characterDefense);
rightSliderHealthAfter.maxValue = rightSliderCurrentHealth.maxValue = characterDefense.m_lifeManager.MaxHealth;
rightSliderCurrentHealth.value = characterDefense.m_lifeManager.Health;
rightSliderHealthAfter.value = characterDefense.m_lifeManager.Health - GetDamage(characterDefense, characterAttack);
this.gameObject.SetActive(true);
}
// Update is called once per frame
void Update()
{
ShowScore();
MovingPin();
if (Input.GetKeyDown(KeyCode.Space))
{
string state = pin.GetComponent <PinControl>().CheckPin();
if (state == "green")
{
score += 10;
}
else if (state == "red")
{
score += 30;
}
else
{
score -= 50;
}
score = Mathf.Clamp(score, -1, 100);
if (score == 100)
{
CharacterManager.Get_instance().houseQuality += 30;
CharacterManager.EndGame();
}
else if (score < 0)
{
CharacterManager.EndGame();
}
InitZone();
}
}
public override void Activate(CharacterManager characterManager)
{
if (isActivated)
{
return;
}
ApplicationManager appDatabase = ApplicationManager.Instance;
if (!appDatabase)
{
return;
}
string powerState = appDatabase.GetGameState("POWER");
string lockdownState = appDatabase.GetGameState("LOCKDOWN");
string accessCodeState = appDatabase.GetGameState("ACCESSCODE");
if (string.IsNullOrEmpty(powerState) || !powerState.Equals("TRUE"))
{
return;
}
if (string.IsNullOrEmpty(lockdownState) || !lockdownState.Equals("FALSE"))
{
return;
}
if (string.IsNullOrEmpty(accessCodeState) || !accessCodeState.Equals("TRUE"))
{
return;
}
//Delay the actual animation for the desired number of seconds
StartCoroutine(DoDelayedActivation(characterManager));
isActivated = true;
}
private void CreatePathCommand()
{
if (selected == null)
{
return;
}
int minGroupPointer = 30;
int minGroupLenght = 1;
int minSinglePointer = 10;
Vector3 startPoint = selected.transform.position;
bool isMin = mousePath.Count > minGroupPointer || UnityExtension.SumPath(mousePath) > minGroupLenght;
ImprovePath();
if (selectedGroup.Count > 1 && isMin)
{
for (int i = 0; i < selectedGroup.Count; i++)
{
if (selectedGroup[i] == null)
{
continue;
}
Vector3 offset = selectedGroup[i].transform.position - startPoint;
List <Vector3> gPath = new List <Vector3>(mousePath);
for (int g = 0; g < gPath.Count; g++)
{
gPath[g] += offset;
}
selectedGroup[i].SetPathCommand(gPath);
}
}
else if (mousePath.Count > minSinglePointer)
{
selected.SetPathCommand(mousePath);
}
selectedGroup.Clear();
selected = null;
mousePath = new List <Vector3>();
}
private void HandleMovement(WowUnit target)
{
// we cant move to a null target
if (target == null)
{
return;
}
// perform a facing check every 250ms, should be enough
if (target.Guid != ObjectManager.PlayerGuid &&
!BotMath.IsFacing(ObjectManager.Player.Position, ObjectManager.Player.Rotation, target.Position) &&
DateTime.Now - LastRotationCheck > TimeSpan.FromMilliseconds(250))
{
HookManager.FacePosition(ObjectManager.Player, target.Position);
CharacterManager.Face(target.Position, target.Guid);
LastRotationCheck = DateTime.Now;
}
// we don't want to move when we are casting or channeling something
if (ObjectManager.Player.CurrentlyCastingSpellId > 0 || ObjectManager.Player.CurrentlyChannelingSpellId > 0)
{
return;
}
// if we are close enough, stop movement and start attacking
double distance = ObjectManager.Player.Position.GetDistance2D(target.Position);
if (distance <= DistanceToTarget)
{
// do we need to stop movement
HookManager.StopClickToMove(ObjectManager.Player);
}
else
{
MovementEngine.SetState(MovementEngineState.Chasing, target.Position);
MovementEngine.Execute();
}
}
public virtual void destroy()
{
mLayoutPrefabManager.destroy();
mCharacterManager.destroy();
mGameSceneManager.destroy();
mAudioManager.destroy();
mLayoutManager.destroy();
mCommandSystem.destroy();
mKeyFrameManager.destroy();
mGlobalTouchSystem.destroy();
mDllImportExtern.destroy();
mShaderManager.destroy();
mDataBase.destroy();
mCameraManager.destroy();
mPluginUtility.destroy();
mModelManager.destroy();
mResourceManager.destroy(); // 资源管理器必须最后销毁,作为最后的资源清理
mLayoutPrefabManager = null;
mResourceManager = null;
mBinaryUtility = null;
mFileUtility = null;
mMathUtility = null;
mStringUtility = null;
mUnityUtility = null;
mPluginUtility = null;
mCommandSystem = null;
mLayoutManager = null;
mAudioManager = null;
mGameSceneManager = null;
mCharacterManager = null;
mKeyFrameManager = null;
mGlobalTouchSystem = null;
mDllImportExtern = null;
mShaderManager = null;
mDataBase = null;
mCameraManager = null;
mModelManager = null;
}
private void PromoteOrDemote(string character, bool isPromote, string channelId = null)
{
var target = CharacterManager.Find(character);
string title = null;
if (channelId != null)
{
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel != null)
{
title = channel.Title;
if (isPromote)
{
channel.CharacterManager.Add(character, ListKind.Moderator);
}
else
{
channel.CharacterManager.Remove(character, ListKind.Moderator);
}
}
}
if (target == null)
{
return;
}
var updateArgs = new PromoteDemoteEventArgs
{
TargetChannelId = channelId,
TargetChannel = title,
IsPromote = isPromote
};
Events.NewCharacterUpdate(target, updateArgs);
}
public JObject ToJson()
{
JObject worldJson = new JObject();
worldJson.Add("Seed", Seed);
worldJson.Add("RandomState", RandomStateToJson());
worldJson.Add("Width", Width.ToString());
worldJson.Add("Height", Height.ToString());
worldJson.Add("Depth", Depth.ToString());
worldJson.Add("Rooms", RoomManager.ToJson());
worldJson.Add("Tiles", TilesToJson());
worldJson.Add("Inventories", InventoryManager.ToJson());
worldJson.Add("Furnitures", FurnitureManager.ToJson());
worldJson.Add("Utilities", UtilityManager.ToJson());
worldJson.Add("RoomBehaviors", RoomManager.BehaviorsToJson());
worldJson.Add("Characters", CharacterManager.ToJson());
worldJson.Add("CameraData", CameraData.ToJson());
worldJson.Add("Skybox", skybox.name);
worldJson.Add("Wallet", Wallet.ToJson());
worldJson.Add("Time", TimeManager.Instance.ToJson());
worldJson.Add("Scheduler", Scheduler.Scheduler.Current.ToJson());
return(worldJson);
}
public MachoNet(ClusterConnection clusterConnection, NodeContainer container, SystemManager systemManager,
ClientManager clientManager, BoundServiceManager boundServiceManager, ItemFactory itemFactory,
Logger logger, AccountDB accountDB, General configuration, CharacterManager characterManager,
NotificationManager notificationManager, TimerManager timerManager, Container dependencyInjection)
{
this.Log = logger.CreateLogChannel("MachoNet");
#if DEBUG
this.CallLog = logger.CreateLogChannel("CallDebug", true);
this.ResultLog = logger.CreateLogChannel("ResultDebug", true);
#endif
this.ClusterConnection = clusterConnection;
this.SystemManager = systemManager;
this.ClientManager = clientManager;
this.BoundServiceManager = boundServiceManager;
this.ItemFactory = itemFactory;
this.Container = container;
this.AccountDB = accountDB;
this.Configuration = configuration;
this.CharacterManager = characterManager;
this.NotificationManager = notificationManager;
this.TimerManager = timerManager;
this.DependencyInjection = dependencyInjection;
}
public PriestHoly(ObjectManager objectManager, CharacterManager characterManager, HookManager hookManager)
{
ObjectManager = objectManager;
CharacterManager = characterManager;
HookManager = hookManager;
CooldownManager = new CooldownManager(characterManager.SpellBook.Spells);
SpellUsageHealDict = new Dictionary <int, string>()
{
{ 0, flashHealSpell },
{ 5000, greaterHealSpell },
};
Spells = new Dictionary <string, Spell>();
CharacterManager.SpellBook.OnSpellBookUpdate += () =>
{
Spells.Clear();
foreach (Spell spell in CharacterManager.SpellBook.Spells)
{
Spells.Add(spell.Name, spell);
}
};
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
// Dispose managed resources here.
}
if (_userManager != null)
{
_userManager.Dispose();
_userManager = null;
}
if (_charManager != null)
{
_charManager.Dispose();
_charManager = null;
}
}
disposed = true;
}
[Hook(HookOrder.LATE)] //This is required so this can be called last, in order for us to know if it's been cancelled or not
void OnPlayerAuthenticated(ref HookContext ctx, ref TDSMHookArgs.PlayerAuthenticationChanged args)
{
if (ctx.Client.State >= 4 && CharacterManager.Mode == CharacterMode.AUTH)
{
#if ENTITY_FRAMEWORK_7
using (var dbCtx = new TContext())
#elif DAPPER
using (var dbCtx = DatabaseFactory.CreateConnection())
#endif
{
using (var txn = dbCtx.BeginTransaction())
{
CharacterManager.LoadForAuthenticated(dbCtx, txn, ctx.Player, !Config.SSC_AllowGuestInfo);
txn.Commit();
}
}
if (Config.SSC_AllowGuestInfo)
{
ctx.Player.SetSSCReadyForSave(true); //Since we aren't issuing out data, and accepting it, we can save it.
}
}
}
public static void ApplyBattleResult(BattlePlayer player, BattlePlayer enemy, CharacterManager playerManager, EnemyManager enemyManager)
{
playerManager.GetCharacterInstance().currentHp = player.GetHp();
enemyManager.GetEnemyInstance().currentHp = enemy.GetHp();
if (state == BattleResultState.PlayerWin)
{
enemyManager.BattleLose();
playerManager.BattleWin();
}
else if (state == BattleResultState.EnemyWin)
{
enemyManager.BattleWin();
playerManager.BattleLose();
}
else if (state == BattleResultState.Draw)
{
enemyManager.BattleLose();
playerManager.BattleLose();
}
state = BattleResultState.None;
}
public void InitializeInn(EventInfo info)
{
characters.Clear();
chars = level.characterManager;
m_info = info;
foreach (string name in m_info.mobs)
{
CharacterInfo c = chars.GetCharacterByName(name);
if (c != null)
{
Debug.Log("Found character named: " + name);
characters.Add(c);
}
}
for (int i = 0; i < 3; i++)
{
slots[i].ToggleSlot(false);
}
for (int i = 0; i < characters.Count && i < 3; i++)
{
slots[i].InitializeSlot(characters[i]);
}
}
private Vector3 positionAudioSource()
{
//pick character nearer to source to determine new position
if (players > 1)
{
//distance between audiosource and character
float p1 = Vector3.Distance(staticPosition, CharacterManager.Get().Characters [0].transform.position);
float p2 = Vector3.Distance(staticPosition, CharacterManager.Get().Characters [1].transform.position);
if (p2 <= p1)
{
return(staticPosition - CharacterManager.Get().Characters [1].transform.position);
}
else
{
return(staticPosition - CharacterManager.Get().Characters [0].transform.position);
}
}
else
{
return(staticPosition - CharacterManager.Get().Characters [0].transform.position);
}
}
void AddClothes(CharacterManager characterManager, int id)
{
SavedSettings.PlayerSettings playerSettings = savedSettings.GetClothes(Data.Instance.settings.disciplinaId, id);
if (playerSettings != null)
{
characterManager.SetCloth(clothesSettings.faces, playerSettings.face);
characterManager.SetCloth(clothesSettings.hairs, playerSettings.hair);
characterManager.SetCloth(clothesSettings.legs, playerSettings.bottom);
characterManager.SetCloth(clothesSettings.shoes, playerSettings.shoes);
characterManager.SetCloth(clothesSettings.tops, playerSettings.body);
characterManager.SetColor(playerSettings.color);
GameObject newNameLabel = Instantiate(NameLabel);
newNameLabel.transform.SetParent(namesContainer.transform);
newNameLabel.transform.localPosition = characterManager.gameObject.transform.parent.localPosition;
newNameLabel.transform.localScale = Vector3.one;
newNameLabel.GetComponentInChildren <TextMesh>().text = playerSettings.username;
}
else
{
characterManager.gameObject.SetActive(false);
}
}
public ShamanRestoration(ObjectManager objectManager, CharacterManager characterManager, HookManager hookManager)
{
ObjectManager = objectManager;
CharacterManager = characterManager;
HookManager = hookManager;
CooldownManager = new CooldownManager(characterManager.SpellBook.Spells);
SpellUsageHealDict = new Dictionary <int, string>()
{
{ 0, riptideSpell },
{ 5000, healingWaveSpell },
};
Spells = new Dictionary <string, Spell>();
CharacterManager.SpellBook.OnSpellBookUpdate += () =>
{
Spells.Clear();
foreach (Spell spell in CharacterManager.SpellBook.Spells)
{
Spells.Add(spell.Name, spell);
}
};
}
private IEnumerator StartSoloGameEnd()
{
// On attend la fin de la création de l'ID du joueur
while (PlayerManager.AllPlayerManagers().Count == 0)
{
yield return(null);
}
PlayerManager playerManager = PlayerManager.AllPlayerManagers()[0];
playerManager.InitializeIngame();
// On attend la fin de la création du personnage
while (playerManager.IngameManager().Character() == null)
{
yield return(null);
}
InitSoloGameUI();
s_localPlayer = playerManager.IngameManager().Character();
m_playerBeerInfo.SetPlayer(s_localPlayer);
StartCoroutine(SoloGameLoop());
}
private static void init()
{
if (null == _instance)
{
_instance = FindObjectOfType(typeof(GameManager)) as GameManager;
}
if (null == characterManager)
{
characterManager = FindObjectOfType(typeof(CharacterManager)) as CharacterManager;
}
if (null == bossManager)
{
bossManager = FindObjectOfType(typeof(BossManager)) as BossManager;
}
if (null == propManager)
{
propManager = FindObjectOfType(typeof(PropManager)) as PropManager;
}
if (null == canvasManager)
{
canvasManager = FindObjectOfType(typeof(CanvasManager)) as CanvasManager;
}
}
// Use this for initialization
void Start()
{
GameObject GameController = GameObject.FindGameObjectWithTag("GameController");
characterManager = GameController.GetComponent <CharacterManager>();
anim = this.GetComponent <Animator>();
if (this.gameObject.tag == "PlatTier1")
{
platWeight = 100;
}
if (this.gameObject.tag == "PlatTier2")
{
platWeight = 150;
}
if (this.gameObject.tag == "PlatTier3")
{
platWeight = 250;
}
}
