public void UseItemSkill(int itemId, GameSkill skill)
{
for (int i = 0; i < mSkillProgressBarList.Count; i++)
{
if (mSkillProgressBarList[i].mItemId == itemId)
{
return;
}
}
for (int i = 0; i < mSkillProgressBarList.Count; i++)
{
if (mSkillProgressBarList[i].SkillEnable == false)
{
mSkillProgressBarList[i].SetItemSkill(itemId, skill.mSkillType);
break;
}
}
//var obj = Instantiate(Resources.Load("Prefab/UISkillProgressBar"), SkillProgressStartPos) as GameObject;
//var progressBar = obj.GetComponent<UISkillProgressBar>();
//progressBar.SetItemSkill(itemId, skill.mSkillType);
////progressBar.gameObject.transform.localPosition = new Vector3(0, mSkillProgressBarList.Count * 80);
//mSkillProgressBarList.Add(progressBar);
UpdateSkillProgressBar();
}
public override void PlusSameSkill(GameSkill data)
{
if (mCount <= ConfigData.Instance.MAX_USE_SHIELD_ITEM)
{
mCount += data.mCount;
}
}
public GameOptions()
{
gameVersion = GameVersion.Version109;
gameMode = GameMode.Commercial;
missionPack = MissionPack.Doom2;
players = new Player[Player.MaxPlayerCount];
for (var i = 0; i < Player.MaxPlayerCount; i++)
{
players[i] = new Player(i);
}
players[0].InGame = true;
consolePlayer = 0;
episode = 1;
map = 1;
skill = GameSkill.Medium;
demoPlayback = false;
netGame = false;
deathmatch = 0;
fastMonsters = false;
respawnMonsters = false;
noMonsters = false;
intermissionInfo = new IntermissionInfo();
random = new DoomRandom();
video = NullVideo.GetInstance();
sound = NullSound.GetInstance();
music = NullMusic.GetInstance();
userInput = NullUserInput.GetInstance();
}
/// <summary>
/// Start a new game.
/// Can be called by the startup code or the menu task.
/// </summary>
public void DeferedInitNew(GameSkill skill, int episode, int map)
{
this.options.Skill = skill;
this.options.Episode = episode;
this.options.Map = map;
this.gameAction = GameAction.NewGame;
}
public void AddSkill(EntityModel skillMode, int posX, int posY)
{
var s = new GameSkill(skillMode);
s.SetPos(posX, posY);
_skills.Add(s);
}
void Start()
{
if (tag == GameManager.PlayerTagName)
{
autoSkill = false;
}
else
{
autoSkill = true;
}
_timerAnim = 0;
curSkillIndexSelect = -1;
ActionHandle = Action_2;
sendingSkill = false;
InitHealthBar();
hp = maxhp;
ConfigAnimation();
if (isConnectedServer())
{
if (role.RoleSkills.Count > 0)
{
//set current skill = deafult skill
GameSkill curSkill = role.RoleSkills[0].GameSkill;
distanceAction = curSkill.CastRange;
}
}
audio = gameObject.AddComponent <AudioSource>();
}
public void setData(GameBattleUnit unit)
{
description.text = "";
selection = GameDefine.INVALID_ID;
for (int i = 0; i < GameDefine.MAX_SLOT; i++)
{
slots[i].clear();
if (unit.Skill[i] == GameDefine.INVALID_ID)
{
continue;
}
GameSkill m = GameSkillData.instance.getData(unit.Skill[i]);
slots[i].setData(m);
slots[i].enable(unit.canUseSkill(m));
if (i == 0)
{
select(0);
}
}
}
public void showItem(GameItem m, GameBattleUnit u, GameBattleAttackMapDirection dir, List <GameBattleAttackResultItem> ri, List <GameBattleAttackResultSkill> r, OnEventOver over)
{
clear();
item = m;
skill = null;
unit = u;
direction = dir;
onEventOver = over;
resultItem = ri;
result = r;
GameUserData.instance.LastItemID = item.ID;
if (item.UseSkillID != GameDefine.INVALID_ID)
{
skill = GameSkillData.instance.getData(item.UseSkillID);
showSkill(skill, u, dir, r, over);
}
else
{
onAttackOverItem();
}
}
public float spiritAddition(GameSkill m, GameSkillAdditionType type)
{
float power = 1.0f;
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
if (m.addition[i].Type == type)
{
if (SpiritPower[i] < m.addition[i].Request)
{
power *= (100.0f + SpiritPower[i] - m.addition[i].Request) / 100.0f;
}
if (SpiritPower[i] > m.addition[i].Plus)
{
power *= (100.0f + SpiritPower[i] - m.addition[i].Plus) / 100.0f;
}
}
}
if (power < 0.1f)
{
power = 0.1f;
}
return(power);
}
public void EndSkillEffect(GameSkill skill)
{
if (skill.mSkillType == SkillManager.SKILL_TYPE.DAMAGE_SHIELD_TIME)
{
SetDoorEffect("IDLE");
}
}
public GameOptions()
{
this.players = new Player[Player.MaxPlayerCount];
for (var i = 0; i < Player.MaxPlayerCount; i++)
{
this.players[i] = new Player(i);
}
this.players[0].InGame = true;
this.consolePlayer = 0;
this.episode = 1;
this.map = 1;
this.skill = GameSkill.Medium;
this.netGame = false;
this.deathmatch = 0;
this.fastMonsters = false;
this.respawnMonsters = false;
this.noMonsters = false;
this.intermissionInfo = new IntermissionInfo();
this.renderer = null;
this.sound = NullSound.GetInstance();
this.music = NullMusic.GetInstance();
this.userInput = NullUserInput.GetInstance();
}
public void StartSkillEffect(GameSkill skill)
{
if (skill.mSkillType == SkillManager.SKILL_TYPE.DAMAGE_SHIELD_TIME)
{
SetAllDoorState(Door.DOOR_STATE.CLOSE, false);
SetDoorEffect("INVINCIBILITY");
}
}
public override void PlusSameSkill(GameSkill data)
{
mTime += data.mTime;
if (mMaxTime < mTime)
{
mTime = mMaxTime;
}
}
public void addSkill(int skillID)
{
Debug.Assert(mUnit.isServer);
GameSkillBuff buff = new GameSkillBuff(GameSkill.get(skillID));
mBuffs.Add(buff);
buff.init(mUnit);
addBuff(buff);
}
public virtual void PlusSameSkill(GameSkill data)
{
mTime += data.mTime;
if (mMaxTime < mTime)
{
mTime = mMaxTime;
}
mCount += data.mCount;
mPercent += data.mPercent;
}
public void showRes(List <GameBattleAttackResultSkill> r, OnEventOver over)
{
skill = null;
unit = null;
result = r;
direction = GameBattleAttackMapDirection.Count;
onEventOver = over;
onAttackOver();
}
public void clear()
{
select.gameObject.SetActive(false);
icon.gameObject.SetActive(false);
text.text = "";
sp.text = "";
mv.text = "";
skill = null;
}
public void updateData(GameUnitBase unitBase)
{
clear();
for (int i = 0; i < GameDefine.MAX_SLOT; i++)
{
GameSkill m = GameSkillData.instance.getData(unitBase.Skills[i]);
slot[i].setData(m);
}
}
public void EndInGameEffect(GameSkill skill)
{
if (skill.mSkillType == SkillManager.SKILL_TYPE.SPEED_DOWN)
{
InGameEffect_Slow.SetActive(false);
}
else if (skill.mSkillType == SkillManager.SKILL_TYPE.SCORE_UP)
{
InGameEffect_Double.SetActive(false);
}
}
public void updateData(GameBattleUnit battleUnit)
{
clear();
for (int i = 0; i < GameDefine.MAX_SLOT; i++)
{
GameSkill m = GameSkillData.instance.getData(battleUnit.Skill[i]);
slot[i].setData(m);
}
}
public void showSkillMap(GameSkill sk, GameBattleUnit u, GameBattleAttackMapDirection dir, List <GameBattleAttackResultSkill> r, OnEventOver over)
{
clear();
skill = sk;
unit = u;
result = r;
direction = dir;
onEventOver = over;
GameUserData.instance.LastSkillID = skill.ID;
// string path = "Prefab/Sprite/man" + GameDefine.getString3( u.Sprite ) + "/" +
// GameDefine.getString3( u.Sprite );
// path += ( m.BattleSprite > 0 ? "-" + m.BattleSprite : "" );
// path += "sm";
//
// GameObject obj = Instantiate<GameObject>( Resources.Load<GameObject>( path ) );
// GameAnimation attackerAnimation = obj.GetComponent<GameAnimation>();
// Transform trans = obj.transform;
// trans.SetParent( transform );
// trans.localScale = Vector3.one;
// trans.localPosition = Vector3.zero;
//
// transform.localPosition = new Vector3( GameSceneMovement.instance.posXReal ,
// GameSceneMovement.instance.posYReal + GameBattleManager.instance.LayerHeight ,
// transform.localPosition.z );
//
// float x = GameCameraManager.instance.sceneWidth / GameDefine.SCENE_WIDTH;
// transform.localScale = new Vector3( x , 1.0f , 1.0f );
//
// if ( dir != GameBattleAttackMapDirection.Count )
// {
// int c = attackerAnimation.safHead.count3[ 0 ];
// int f = c * (int)dir;
//
// attackerAnimation.playAnimation( f , f + c , false , onAttackOver );
// }
// else
// {
// attackerAnimation.playAnimation( 0 , GameDefine.INVALID_ID , false , onAttackOver );
// }
if (skill.AttackRangeType == GameAttackRangeType.Line)
{
GameBattleSceneMovement.instance.moveTo(unit.PosX - GameCameraManager.instance.xCell,
unit.PosY - GameCameraManager.instance.yCell, 50, 50, onStartMoveOver);
}
else
{
GameBattleSceneMovement.instance.moveTo(GameBattleCursor.instance.PosX - GameCameraManager.instance.xCell,
GameBattleCursor.instance.PosY - GameCameraManager.instance.yCell, 50, 50, onStartMoveOver);
}
}
public GameSkill AddUseSkill(string skillName)
{
SkillData skillData = DataManager.Instance.SkillDataList[skillName];
SKILL_TYPE skillType = ConvertSkillType(skillData.skilltype);
GameSkill data = null;
switch (skillType)
{
case SKILL_TYPE.DAMAGE_SHIELD_TIME:
data = new GameSkill_DamageShieldTime(skillName);
break;
case SKILL_TYPE.DAMAGE_SHIELD_COUNT:
data = new GameSkill_DamageShieldCount(skillName);
break;
case SKILL_TYPE.SCORE_UP:
data = new GameSkill_ScoreUP(skillName);
break;
case SKILL_TYPE.SPEED_DOWN:
data = new GameSkill_SpeedDown(skillName);
break;
case SKILL_TYPE.RESURRECTION:
data = new GameSkill_Resurrection(skillName);
break;
case SKILL_TYPE.GAME_OVER_SCORE_BONUS:
data = new GameSkill_GameOverScoreBonus(skillName);
break;
case SKILL_TYPE.GAME_OVER_COIN_BONUS:
data = new GameSkill_GameOverCoinBonus(skillName);
break;
case SKILL_TYPE.ITEM_CREATE:
data = new GameSkill_ItemCreate(skillName);
break;
default:
break;
}
if (data != null)
{
AddUseSkill(data);
data.StartSkill();
}
return(data);
}
private void AddUseSkill(GameSkill data)
{
var skillType = data.mSkillType;
if (mUseSkillList.ContainsKey(skillType) == false)
{
mUseSkillList.Add(skillType, data);
}
else
{
mUseSkillList[skillType].PlusSameSkill(data);
}
}
public bool canUseSkillMove(GameSkill m, int cost)
{
if (checkEffect(GameSkillResutlEffect.Silence))
{
return(false);
}
if (m.MoveAttackType == GameSkillMoveAttackType.Stand)
{
return(false);
}
return(m.MoveCost <= Move - cost && m.MPCost <= MP);
}
public bool isSkillNeedTarget(GameSkill curSkill)
{
if (curSkill.TargetType == (int)TargetType.AllyOne ||
curSkill.TargetType == (int)TargetType.EnemyOne ||
(curSkill.TargetType == (int)TargetType.AreaEffect && curSkill.EffectRange > 0) ||
curSkill.Id == 29) //Garuda
{
return(true);
}
else
{
return(false);
}
}
override public void Init()
{
base.Init();
InitUI();
_gameskill = BattleGame.instance.gameSkill;
if (InstancePlayer.instance.pvpUser == null)
{
skillGrid.gameObject.SetActive(true);
InitSkillItem(_gameskill.GetSkillCount());
}
else
{
skillGrid.gameObject.SetActive(false);
}
}
void updateSkillUI()
{
if (!GameBattleSkillUI.instance.IsShow)
{
return;
}
if (confirm)
{
confirm = false;
skill = GameBattleSkillUI.instance.getSelectionSkill();
if (skill == null)
{
return;
}
GameBattleUnit unit = GameBattleSelection.instance.SelectionUnit;
GameBattleUnitSkillSelection.instance.show(unit.PosX, unit.PosY, skill, unit.UnitCampType, true);
GameBattleSkillUI.instance.unShowFade();
GameBattleCursor.instance.moveTo(GameBattleUnitSkillSelection.instance.AttackCell.x,
GameBattleUnitSkillSelection.instance.AttackCell.y,
GameBattleCursor.SpeedX, GameBattleCursor.SpeedY,
true,
onCursorMoveOver);
return;
}
if (cancel)
{
cancel = false;
GameBattleSkillUI.instance.unShowFade();
GameBattleUnitActionUI.instance.show();
GameBattleUnitActionUI.instance.enable(true);
GameBattleUnitActionUI.instance.showFade();
return;
}
moveSkillUI();
}
public void setData(GameSkill skill)
{
clear();
if (skill == null)
{
return;
}
text.text = skill.Name;
mp.text = GameDefine.getBigInt(skill.MPCost.ToString());
move.text = GameDefine.getBigInt(skill.MoveCost.ToString());
image.gameObject.SetActive(true);
}
/// <summary>
/// 更新数据
/// </summary>
public void UpdateData(int index)
{
_currentIndex = index;
_gameSkill = BattleGame.instance.gameSkill;
_skillData = _gameSkill.GetData(_currentIndex);
if (_skillData != null)
{
// NGUITools.SetActive(this.icon.gameObject, true);
this._sillName.text = _skillData.name;
this._skillIcon.spriteName = "SkillICONS_" + (int)_skillData.type;
}
else
{
this._sillName.text = "";
// NGUITools.SetActive(this.icon.gameObject, false);
}
}
public void addSkill(GameSkill skill)
{
Object obj = Instantiate(buttonAction);
(obj as GameObject).transform.parent = this.transform;
(obj as GameObject).GetComponent<GUIText>().pixelOffset = new Vector2(210, 80 + 40 * _count);
(obj as GameObject).GetComponent<GUIText>().text = skill.name;
(obj as GameObject).GetComponent<ButtonUseSkill>().action = OptionType.Special;
(obj as GameObject).GetComponent<ButtonUseSkill>().skill = skill;
_buttons.SetValue(obj, _count);
_skills.SetValue(skill, _count);
_count++;
}
public void setData(GameSkill m)
{
clear();
if (m == null)
{
return;
}
skill = m;
text.text = m.Name;
sp.text = GameDefine.getBigInt(m.MPCost.ToString());
mv.text = GameDefine.getBigInt(m.MoveCost.ToString());
icon.gameObject.SetActive(true);
}
