public void updateData(GameUnitBase unitBase)
{
unitUIStage.updateData(unitBase);
unitUIInfo.updateData(unitBase);
unitUIItem.updateData(unitBase);
unitUISkill.updateData(unitBase);
}
public void showItemAskUI(GameItemBagUI other)
{
GameItemAskUIType[] t = new GameItemAskUIType[GameItemAskUI.MAX_SLOT];
bool[] e = new bool[GameItemAskUI.MAX_SLOT];
if (type == GameItemBagUIType.Bag)
{
t[0] = GameItemAskUIType.Give;
t[1] = GameItemAskUIType.Equip;
t[2] = GameItemAskUIType.Drop;
e[0] = !other.itemFull();
e[1] = false;
e[2] = true;
}
else
{
GameUnitBase unit = GameUserData.instance.getUnitBase(userID);
t[0] = GameItemAskUIType.Give;
t[2] = GameItemAskUIType.Drop;
e[0] = false;
e[2] = false;
if (unit.WeaponSlot == selection)
{
t[1] = GameItemAskUIType.UnEquip;
e[1] = false;
}
else if (unit.ArmorSlot == selection)
{
t[1] = GameItemAskUIType.UnEquip;
e[1] = false;
}
else if (unit.AccessorySlot == selection)
{
t[1] = GameItemAskUIType.UnEquip;
e[1] = true;
}
else
{
t[1] = GameItemAskUIType.Equip;
e[1] = getItem().canEquip(userID);
e[0] = !other.itemFull();
e[2] = true;
}
}
itemAskUI.show(t, e);
itemAskUI.setPos(100.0f, slot[pos].GetComponent <RectTransform>().anchoredPosition.y);
itemAskUI.select(0);
}
public void load(string path)
{
FileStream fs = File.OpenRead(path);
byte[] bytes = new byte[fs.Length];
fs.Read(bytes, 0, (int)fs.Length);
data = new GameUnitBase[GameDefine.MAX_USER];
int index = 0;
for (int i = 0; i < GameDefine.MAX_USER; ++i)
{
GameUnitBase unit = new GameUnitBase();
unit.UnitID = BitConverter.ToInt16(bytes, index); index += 2;
unit.LV = BitConverter.ToInt16(bytes, index); index += 2;
unit.Exp = BitConverter.ToInt16(bytes, index); index += 2;
unit.HP = BitConverter.ToUInt16(bytes, index); index += 2;
unit.MP = BitConverter.ToUInt16(bytes, index); index += 2;
unit.Str = BitConverter.ToInt16(bytes, index); index += 2;
unit.Int = BitConverter.ToInt16(bytes, index); index += 2;
unit.Avg = BitConverter.ToInt16(bytes, index); index += 2;
unit.Vit = BitConverter.ToInt16(bytes, index); index += 2;
unit.Luk = BitConverter.ToInt16(bytes, index); index += 2;
for (int k = 0; k < (int)GameSpiritType.Count; k++)
{
unit.SpiritPower[k] = BitConverter.ToInt16(bytes, index); index += 2;
}
unit.Weapon = BitConverter.ToInt16(bytes, index); index += 2;
unit.Armor = BitConverter.ToInt16(bytes, index); index += 2;
unit.Accessory = BitConverter.ToInt16(bytes, index); index += 2;
unit.InTeam = BitConverter.ToInt16(bytes, index); index += 2;
unit.BaseSpiritPower = BitConverter.ToInt16(bytes, index); index += 2;
for (int k = 0; k < GameDefine.MAX_SLOT; k++)
{
unit.Items[k] = BitConverter.ToInt16(bytes, index); index += 2;
}
for (int k = 0; k < GameDefine.MAX_SLOT; k++)
{
unit.Skills[k] = BitConverter.ToInt16(bytes, index); index += 2;
}
data[i] = unit;
}
Debug.Log("GameUnitInitData loaded.");
}
public void onDownClick()
{
GameUnitBase u = GameUserData.instance.getUnitBase(userID);
if (tempData[userID].power[selection] > 0)
{
tempData[userID].power[selection]--;
}
updateData(u);
}
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 updateData(GameUnitBase unitBase)
{
clear();
for (int i = 0; i < GameDefine.MAX_SLOT; i++)
{
GameItem item = GameItemData.instance.getData(unitBase.Items[i]);
bool b = (unitBase.AccessorySlot == i || unitBase.ArmorSlot == i || unitBase.WeaponSlot == i);
slot[i].setData(item, b);
}
}
public Item removeItem()
{
if (items[selection].type == GameAlchemyUIType.User)
{
GameUnitBase unit = GameUserData.instance.getUnitBase(items[selection].userID);
unit.removeItem(items[selection].itemSlot);
}
else
{
GameUserData.instance.removeItem(items[selection].itemSlot);
}
return(items[selection]);
}
public void updateData(GameUnitBase unitBase)
{
GameUnit unit = GameUnitData.instance.getData(unitBase.UnitID);
nameText.text = unit.Name;
short count = 0;
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
count += tempData[userID].power[i];
}
text.text = GameDefine.getBigInt((unitBase.BaseSpiritPower - count).ToString());
textMax.text = GameDefine.getBigInt(unitBase.BaseSpiritPower.ToString());
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
int p = unitBase.SpiritPower[i] + tempData[userID].power[i];
powerText[i].text = GameDefine.getBigInt(p.ToString());
if (tempData[userID].power[i] > 0)
{
powerText[i].color = new Color(0.0f, 0.5f, 1.0f);
}
else
{
powerText[i].color = textColor;
}
int f = (int)(p / 10.0f);
if (p % 10 > 0)
{
f += 1;
}
if (f > 10)
{
f = 10;
}
if (p > 0)
{
power[i].showFrame(3 + f);
}
}
}
public void show(int id)
{
userID = id;
show();
GameUnitBase u = GameUserData.instance.getUnitBase(userID);
updateData(u);
unitUIInfo.gameObject.SetActive(true);
unitUIItem.gameObject.SetActive(false);
unitUISkill.gameObject.SetActive(false);
updateAnimation();
}
public void onClickAskUI()
{
unShowAskUI();
if (bagUI1.IsOKAskUI)
{
GameItem item1 = bagUI0.getItem();
GameItem item2 = bagUI1.getItem();
short id = GameUserData.instance.getAlchemyItem(item1.ID, item2.ID);
GameAlchemyUIBag.Item item = null;
if (bagUI0.Selection > bagUI1.Selection)
{
item = bagUI0.removeItem();
bagUI1.removeItem();
}
else
{
bagUI1.removeItem();
item = bagUI0.removeItem();
}
if (item.type == GameAlchemyUIType.User)
{
GameUnitBase unit = GameUserData.instance.getUnitBase(item.userID);
unit.addItem(id);
}
else
{
GameUserData.instance.addItem(id);
}
bagUI0.addItems();
bagUI1.addItems();
bagUI0.select(0);
showAlchemy(false);
}
else
{
}
}
public void addItems()
{
items.Clear();
for (int i = 0; i < GameDefine.MAX_USER; i++)
{
GameUnitBase unit = GameUserData.instance.getUnitBase(i);
if (unit.InTeam == 0)
{
continue;
}
for (int j = 0; j < GameDefine.MAX_SLOT; j++)
{
if (unit.Items[j] != GameDefine.INVALID_ID &&
j != unit.WeaponSlot &&
j != unit.ArmorSlot &&
j != unit.AccessorySlot)
{
Item item = new Item();
item.userID = i;
item.type = GameAlchemyUIType.User;
item.itemSlot = j;
item.itemID = unit.Items[j];
items.Add(item);
}
}
}
for (int j = 0; j < GameDefine.MAX_ITEMBAG; j++)
{
if (GameUserData.instance.ItemBag[j] != GameDefine.INVALID_ID)
{
Item item = new Item();
item.userID = GameDefine.INVALID_ID;
item.type = GameAlchemyUIType.Bag;
item.itemSlot = j;
item.itemID = GameUserData.instance.ItemBag[j];
items.Add(item);
}
}
}
public GameBattleUnit summonUnit(GameBattleUnit u, int id, int x, int y)
{
GameBattleUnit battleUnit = getUnitByID(id);
if (battleUnit == null)
{
return(null);
}
if (battleUnit.IsShow || battleUnit.IsKilled)
{
return(null);
}
GameUnit unit = GameUnitData.instance.getData(battleUnit.UnitID);
battleUnit.IsShow = true;
battleUnit.IsSummon = true;
GameUnitBase unitBaseU = u.getUnitBase();
GameUnitBase unitBase = battleUnit.getUnitBase();
unitBase.LV = unitBaseU.LV;
unitBase.HP = (short)(unitBaseU.HP * unit.HP / 100.0f);
unitBase.MP = (short)(unitBaseU.MP * unit.MP / 100.0f);
unitBase.Str = (short)(unitBaseU.Str * unit.Str / 100.0f);
unitBase.Vit = (short)(unitBaseU.Vit * unit.Vit / 100.0f);
unitBase.Avg = (short)(unitBaseU.Avg * unit.Avg / 100.0f);
unitBase.Int = (short)(unitBaseU.Int * unit.Int / 100.0f);
unitBase.Luk = (short)(unitBaseU.Luk * unit.Luk / 100.0f);
battleUnit.updateUnitData();
battleUnit.initHPMP();
battleUnit.clearMove();
battleUnit.setPos(x, y);
battleUnit.updateAnimation(GameAnimationDirection.South);
battleUnit.updateAlive();
return(battleUnit);
}
public bool itemFull()
{
switch (type)
{
case GameItemBagUIType.User:
{
GameUnitBase unit = GameUserData.instance.getUnitBase(userID);
return(unit.itemFull());
}
case GameItemBagUIType.Bag:
{
return(GameUserData.instance.itemFull());
}
}
return(false);
}
public void show(int id, bool c)
{
if (c)
{
clearTempData();
}
isShowUser = false;
powerObject.SetActive(true);
userID = id;
show();
GameUnitBase u = GameUserData.instance.getUnitBase(id);
updateData(u);
left.playAnimation(14, 18);
right.playAnimation(18, 22);
}
public void onUpClick()
{
GameUnitBase u = GameUserData.instance.getUnitBase(userID);
short count = 0;
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
count += tempData[userID].power[i];
}
if (u.BaseSpiritPower > count)
{
if (u.SpiritPower[selection] + tempData[userID].power[selection] == GameDefine.MAX_POWER)
{
return;
}
tempData[userID].power[selection]++;
}
updateData(u);
}
public void onAskUIClick()
{
for (int j = 0; j < GameDefine.MAX_USER; j++)
{
GameUnitBase u = GameUserData.instance.getUnitBase(j);
short count = 0;
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
count += tempData[j].power[i];
}
if (u.BaseSpiritPower >= count)
{
u.BaseSpiritPower -= count;
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
u.SpiritPower[i] += tempData[j].power[i];
}
}
}
}
public void showItem(GameUnitBase unitBase, GameItem item)
{
GameUnit gameUnit = GameUnitData.instance.getData(unitBase.UnitID);
GameBattleUnitData unitData = new GameBattleUnitData();
GameBattleUnitData unitData1 = new GameBattleUnitData();
GameItem weapon = GameItemData.instance.getData(unitBase.Weapon);
GameItem armor = GameItemData.instance.getData(unitBase.Armor);;
GameItem accessory = GameItemData.instance.getData(unitBase.Accessory);;
GameAttributeDefence md = GameAttributeDefenceData.instance.getData(gameUnit.AttributeDefenceID);
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
if (md != null)
{
unitData.AttributeDefence[i] = md.AttributeDefence[i];
}
else
{
unitData.AttributeDefence[i] = 100;
}
}
unitData.Attack += unitBase.Str;
unitData.Defence += unitBase.Vit / 2;
if (weapon != null)
{
unitData.Attack += weapon.Attack;
unitData.Defence += weapon.Defence;
unitData.Hit += weapon.AttackHit;
unitData.Miss += weapon.AttackMiss;
unitData.Critical += weapon.AttackCritical;
unitData.Double += weapon.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData.AttributeDefence[i] -= (short)(weapon.AttributeDefence[i] * unitData.AttributeDefence[i] / 100.0f);
}
}
if (armor != null)
{
unitData.Attack += armor.Attack;
unitData.Defence += armor.Defence;
unitData.Hit += armor.AttackHit;
unitData.Miss += armor.AttackMiss;
unitData.Critical += armor.AttackCritical;
unitData.Double += armor.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData.AttributeDefence[i] -= (short)(armor.AttributeDefence[i] * unitData.AttributeDefence[i] / 100.0f);
}
}
if (accessory != null)
{
unitData.Attack += accessory.Attack;
unitData.Defence += accessory.Defence;
unitData.Hit += accessory.AttackHit;
unitData.Miss += accessory.AttackMiss;
unitData.Critical += accessory.AttackCritical;
unitData.Double += accessory.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData.AttributeDefence[i] -= (short)(accessory.AttributeDefence[i] * unitData.AttributeDefence[i] / 100.0f);
}
}
if (item != null)
{
unitData1.Attack = unitData.Attack;
unitData1.Defence = unitData.Defence;
unitData1.Hit = unitData.Hit;
unitData1.Miss = unitData.Miss;
unitData1.Critical = unitData.Critical;
unitData1.Double = unitData.Double;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData1.AttributeDefence[i] = unitData.AttributeDefence[i];
}
if (weapon != null && item.ItemType == GameItemType.Weapon)
{
unitData1.Attack -= weapon.Attack;
unitData1.Defence -= weapon.Defence;
unitData1.Hit -= weapon.AttackHit;
unitData1.Miss -= weapon.AttackMiss;
unitData1.Critical -= weapon.AttackCritical;
unitData1.Double -= weapon.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData1.AttributeDefence[i] += (short)(weapon.AttributeDefence[i] * unitData1.AttributeDefence[i] / 100.0f);
}
}
if (armor != null && item.ItemType == GameItemType.Armor)
{
unitData1.Attack -= armor.Attack;
unitData1.Defence -= armor.Defence;
unitData1.Hit -= armor.AttackHit;
unitData1.Miss -= armor.AttackMiss;
unitData1.Critical -= armor.AttackCritical;
unitData1.Double -= armor.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData1.AttributeDefence[i] += (short)(armor.AttributeDefence[i] * unitData1.AttributeDefence[i] / 100.0f);
}
}
if (accessory != null && item.ItemType == GameItemType.Accessory)
{
unitData1.Attack -= accessory.Attack;
unitData1.Defence -= accessory.Defence;
unitData1.Hit -= accessory.AttackHit;
unitData1.Miss -= accessory.AttackMiss;
unitData1.Critical -= accessory.AttackCritical;
unitData1.Double -= accessory.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData1.AttributeDefence[i] += (short)(accessory.AttributeDefence[i] * unitData1.AttributeDefence[i] / 100.0f);
}
}
unitData1.Attack += item.Attack;
unitData1.Defence += item.Defence;
unitData1.Hit += item.AttackHit;
unitData1.Miss += item.AttackMiss;
unitData1.Critical += item.AttackCritical;
unitData1.Double += item.AttackDouble;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
unitData1.AttributeDefence[i] -= (short)(item.AttributeDefence[i] * unitData1.AttributeDefence[i] / 100.0f);
}
}
attack.text = GameDefine.getBigInt(unitData.Attack.ToString());
defence.text = GameDefine.getBigInt(unitData.Defence.ToString());
hit.text = GameDefine.getBigInt(unitData.Hit.ToString());
speed.text = GameDefine.getBigInt(unitData.Miss.ToString());
fire.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Fire].ToString());
thunder.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Thunder].ToString());
ice.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Ice].ToString());
illusion.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Illusion].ToString());
light0.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Light].ToString());
dark.text = GameDefine.getBigInt(unitData.AttributeDefence[(int)GameAttributeType.Dark].ToString());
attack1.text = GameDefine.getBigInt(unitData1.Attack.ToString());
defence1.text = GameDefine.getBigInt(unitData1.Defence.ToString());
hit1.text = GameDefine.getBigInt(unitData1.Hit.ToString());
speed1.text = GameDefine.getBigInt(unitData1.Miss.ToString());
fire1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Fire].ToString());
thunder1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Thunder].ToString());
ice1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Ice].ToString());
illusion1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Illusion].ToString());
light1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Light].ToString());
dark1.text = GameDefine.getBigInt(unitData1.AttributeDefence[(int)GameAttributeType.Dark].ToString());
attack1.color = defaultColor;
defence1.color = defaultColor;
hit1.color = defaultColor;
speed1.color = defaultColor;
fire1.color = defaultColor;
thunder1.color = defaultColor;
ice1.color = defaultColor;
illusion1.color = defaultColor;
light1.color = defaultColor;
dark1.color = defaultColor;
Color colorRed = Color.red;
Color colorGreen = new Color(0.0f, 0.39f, 0.0f);
if (unitData1.Attack > unitData.Attack)
{
attack1.color = Color.red;
}
if (unitData1.Defence > unitData.Defence)
{
defence1.color = Color.red;
}
if (unitData1.Hit > unitData.Hit)
{
hit1.color = Color.red;
}
if (unitData1.Miss > unitData.Miss)
{
speed1.color = Color.red;
}
if (unitData1.Attack < unitData.Attack)
{
attack1.color = colorGreen;
}
if (unitData1.Defence < unitData.Defence)
{
defence1.color = colorGreen;
}
if (unitData1.Hit < unitData.Hit)
{
hit1.color = colorGreen;
}
if (unitData1.Miss < unitData.Miss)
{
speed1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Fire] < unitData.AttributeDefence[(int)GameAttributeType.Fire])
{
fire1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Thunder] < unitData.AttributeDefence[(int)GameAttributeType.Thunder])
{
thunder1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Ice] < unitData.AttributeDefence[(int)GameAttributeType.Ice])
{
ice1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Illusion] < unitData.AttributeDefence[(int)GameAttributeType.Illusion])
{
illusion1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Light] < unitData.AttributeDefence[(int)GameAttributeType.Light])
{
light1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Dark] < unitData.AttributeDefence[(int)GameAttributeType.Dark])
{
dark1.color = Color.red;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Fire] > unitData.AttributeDefence[(int)GameAttributeType.Fire])
{
fire1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Thunder] > unitData.AttributeDefence[(int)GameAttributeType.Thunder])
{
thunder1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Ice] > unitData.AttributeDefence[(int)GameAttributeType.Ice])
{
ice1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Illusion] > unitData.AttributeDefence[(int)GameAttributeType.Illusion])
{
illusion1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Light] > unitData.AttributeDefence[(int)GameAttributeType.Light])
{
light1.color = colorGreen;
}
if (unitData1.AttributeDefence[(int)GameAttributeType.Dark] > unitData.AttributeDefence[(int)GameAttributeType.Dark])
{
dark1.color = colorGreen;
}
}
protected override void onUpdate()
{
if (!shopUI.gameObject.activeSelf &&
!bagUI.gameObject.activeSelf)
{
return;
}
GameUnitBase unitBase = null;
GameItem item = null;
if (shopUI.Enabled)
{
item = shopUI.getItem();
if (shopUI.UserID != GameDefine.INVALID_ID)
{
unitBase = GameUserData.instance.getUnitBase(shopUI.UserID);
}
else
{
unitBase = GameUserData.instance.getUnitBase(bagUI.UserID);
}
}
else
{
item = bagUI.getItem();
if (bagUI.UserID != GameDefine.INVALID_ID)
{
unitBase = GameUserData.instance.getUnitBase(bagUI.UserID);
}
else
{
unitBase = GameUserData.instance.getUnitBase(shopUI.UserID);
}
}
if (unitBase == null || item == null)
{
return;
}
if (!item.canEquip(unitBase.UnitID))
{
return;
}
time += Time.deltaTime;
if (time > 1.0f)
{
time = -9999;
if (!GameEquipInfoUI.instance.IsShow)
{
GameEquipInfoUI.instance.showItem(unitBase, item);
if (shopUI.Enabled)
{
GameEquipInfoUI.instance.setPos(57.0f, -18.0f);
}
else
{
GameEquipInfoUI.instance.setPos(-57.0f, -18.0f);
}
GameEquipInfoUI.instance.show();
GameEquipInfoUI.instance.showFade();
}
}
}
public void onClickAskUI()
{
if (shopUI.Enabled)
{
shopUI.unShowAskUI();
if (shopUI.IsOKAskUI)
{
// buy
GameItem item = shopUI.getItem();
if (item == null)
{
return;
}
switch (bagUI.Type)
{
case GameItemBagUI.GameItemBagUIType.User:
{
GameUnitBase unit = GameUserData.instance.getUnitBase(bagUI.UserID);
unit.addItem(item.ID);
GameUserData.instance.addGold(-item.Price);
bagUI.setItems(unit.Items);
bagUI.updateItems();
bagUI.enable(false);
shopUI.updateItems();
shopUI.select(shopUI.Selection);
updateText();
}
break;
case GameItemBagUI.GameItemBagUIType.Bag:
{
GameUserData.instance.addItem(item.ID);
GameUserData.instance.addGold(-item.Price);
bagUI.setItems(GameUserData.instance.ItemBag);
bagUI.updateItems();
bagUI.enable(false);
shopUI.updateItems();
shopUI.select(shopUI.Selection);
updateText();
}
break;
}
}
}
else
{
bagUI.unShowAskUI();
if (bagUI.IsOKAskUI)
{
// sell
GameItem item = bagUI.getItem();
int itemSlot = bagUI.getItemSlot();
switch (bagUI.Type)
{
case GameItemBagUI.GameItemBagUIType.User:
{
GameUnitBase unit = GameUserData.instance.getUnitBase(bagUI.UserID);
unit.removeItem(itemSlot);
GameUserData.instance.addGold(item.Price / 2);
bagUI.setItems(unit.Items);
bagUI.updateItems();
bagUI.select(bagUI.Selection - 1);
updateText();
}
break;
case GameItemBagUI.GameItemBagUIType.Bag:
{
GameUserData.instance.removeItem(itemSlot);
GameUserData.instance.addGold(item.Price / 2);
bagUI.setItems(GameUserData.instance.ItemBag);
bagUI.updateItems();
bagUI.select(bagUI.Selection - 1);
updateText();
}
break;
}
}
}
if (GameEquipInfoUI.instance.IsShow)
{
GameEquipInfoUI.instance.unShowFade();
}
}
public void setUnitBase(GameUnitBase b)
{
gameBattleMan.UnitBase = b;
}
public void giveItem(int slot, GameUnitBase unit)
{
unit.addItem(Items[slot]);
removeItem(slot);
}
public void updateData(GameUnitBase unitBase)
{
clear();
GameUnit gameUnit = GameUnitData.instance.getData(unitBase.UnitID);
short Str = unitBase.Str;
short Vit = unitBase.Vit;
short Avg = unitBase.Avg;
short Int = unitBase.Int;
short Luk = unitBase.Luk;
short[] AttributeDefence = new short[(int)GameAttributeType.Cure];
GameAttributeDefence md = GameAttributeDefenceData.instance.getData(gameUnit.AttributeDefenceID);
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
if (md != null)
{
AttributeDefence[i] = md.AttributeDefence[i];
}
else
{
AttributeDefence[i] = 100;
}
}
int atk = 0;
int def = 0;
int mag = Int;
int spd = Avg;
GameItem weapon = GameItemData.instance.getData(unitBase.Weapon);
GameItem armor = GameItemData.instance.getData(unitBase.Armor);
GameItem accessory = GameItemData.instance.getData(unitBase.Accessory);
if (weapon != null)
{
atk += weapon.Attack;
def += weapon.Defence;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
AttributeDefence[i] -= (short)(weapon.AttributeDefence[i] * AttributeDefence[i] / 100.0f);
}
}
if (armor != null)
{
atk += armor.Attack;
def += armor.Defence;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
AttributeDefence[i] -= (short)(armor.AttributeDefence[i] * AttributeDefence[i] / 100.0f);
}
}
if (accessory != null)
{
atk += accessory.Attack;
def += accessory.Defence;
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
AttributeDefence[i] -= (short)(accessory.AttributeDefence[i] * AttributeDefence[i] / 100.0f);
}
}
atk += Str;
def += (short)(Vit / 2.0f);
atkText.text = GameDefine.getBigInt(atk.ToString());
defText.text = GameDefine.getBigInt(def.ToString());
magText.text = GameDefine.getBigInt(mag.ToString());
spdText.text = GameDefine.getBigInt(spd.ToString());
for (int i = 0; i <= (int)GameAttributeType.Dark; i++)
{
int ad = AttributeDefence[i];
if (ad > 100)
{
ad = 100;
}
if (ad < -100)
{
ad = -100;
}
if (ad > 0)
{
red[i].gameObject.SetActive(false);
blue[i].gameObject.SetActive(true);
red[i].anchoredPosition = new Vector2(-1.5f - width, 0.0f);
blue[i].anchoredPosition = new Vector2(-1.5f - width * (1.0f - ad / 100.0f), 0.0f);
}
else
{
red[i].gameObject.SetActive(true);
blue[i].gameObject.SetActive(false);
blue[i].anchoredPosition = new Vector2(-1.5f + width, 0.0f);
red[i].anchoredPosition = new Vector2(-1.5f - width * (1.0f + ad / 100.0f), 0.0f);
}
textTypes[i].text = GameDefine.getBigInt(Mathf.Abs(AttributeDefence[i]).ToString());
}
}
public void onClickAskUI()
{
unShowAskUI();
int selection = GameDefine.INVALID_ID;
GameItemBagUI.GameItemBagUIType uiType = GameItemBagUI.GameItemBagUIType.Count;
int itemSlot = GameDefine.INVALID_ID;
if (bagUI0.Enabled)
{
if (bagUI0.IsEnabledItemAskUI)
{
selection = bagUI0.SelectionItemAskUI;
uiType = bagUI0.Type;
itemSlot = bagUI0.getItemSlot();
if (uiType == GameItemBagUI.GameItemBagUIType.User)
{
GameUnitBase unit0 = GameUserData.instance.getUnitBase(bagUI0.UserID);
unit0.removeItem(itemSlot);
}
else
{
GameUserData.instance.removeItem(itemSlot);
}
if (bagUI0.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI0.setItems(GameUserData.instance.getUnitBase(bagUI0.UserID).Items);
}
else
{
bagUI0.setItems(GameUserData.instance.ItemBag);
}
if (bagUI1.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI1.setItems(GameUserData.instance.getUnitBase(bagUI1.UserID).Items);
}
else
{
bagUI1.setItems(GameUserData.instance.ItemBag);
}
bagUI0.unshowItemAskUI();
bagUI0.updateItems();
bagUI1.updateItems();
bagUI1.enable(false);
bagUI0.select(bagUI0.Selection);
}
}
else
{
if (bagUI1.IsEnabledItemAskUI)
{
selection = bagUI1.SelectionItemAskUI;
uiType = bagUI1.Type;
itemSlot = bagUI1.getItemSlot();
if (uiType == GameItemBagUI.GameItemBagUIType.User)
{
GameUnitBase unit1 = GameUserData.instance.getUnitBase(bagUI1.UserID);
unit1.removeItem(itemSlot);
}
else
{
GameUserData.instance.removeItem(itemSlot);
}
if (bagUI0.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI0.setItems(GameUserData.instance.getUnitBase(bagUI0.UserID).Items);
}
else
{
bagUI0.setItems(GameUserData.instance.ItemBag);
}
if (bagUI1.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI1.setItems(GameUserData.instance.getUnitBase(bagUI1.UserID).Items);
}
else
{
bagUI1.setItems(GameUserData.instance.ItemBag);
}
bagUI1.unshowItemAskUI();
bagUI1.updateItems();
bagUI0.updateItems();
bagUI0.enable(false);
bagUI1.select(bagUI1.Selection);
}
}
if (GameEquipInfoUI.instance.IsShow)
{
GameEquipInfoUI.instance.unShowFade();
}
}
public void onClickItemAskUI()
{
int selection = GameDefine.INVALID_ID;
GameItemBagUI.GameItemBagUIType uiType = GameItemBagUI.GameItemBagUIType.Count;
int itemSlot = GameDefine.INVALID_ID;
if (bagUI0.Enabled)
{
if (bagUI0.IsEnabledItemAskUI)
{
selection = bagUI0.SelectionItemAskUI;
uiType = bagUI0.Type;
itemSlot = bagUI0.getItemSlot();
if (uiType == GameItemBagUI.GameItemBagUIType.User)
{
GameUnitBase unit0 = GameUserData.instance.getUnitBase(bagUI0.UserID);
switch (selection)
{
case 0:
{
if (bagUI1.Type == GameItemBagUI.GameItemBagUIType.Bag)
{
short itemID = unit0.Items[itemSlot];
unit0.removeItem(itemSlot);
GameUserData.instance.addItem(itemID);
}
else
{
GameUnitBase unit1 = GameUserData.instance.getUnitBase(bagUI1.UserID);
short itemID = unit0.Items[itemSlot];
unit0.removeItem(itemSlot);
unit1.addItem(itemID);
}
}
break;
case 1:
{
if (unit0.AccessorySlot == itemSlot)
{
unit0.Accessory = GameDefine.INVALID_ID;
}
else
{
short itemID = unit0.Items[itemSlot];
GameItem item = GameItemData.instance.getData(unit0.Items[itemSlot]);
switch (item.ItemType)
{
case GameItemType.Weapon:
unit0.Weapon = itemID;
break;
case GameItemType.Armor:
unit0.Armor = itemID;
break;
case GameItemType.Accessory:
unit0.Accessory = itemID;
break;
}
}
}
break;
case 2:
{
showAskUI(false);
}
break;
}
}
else
{
switch (selection)
{
case 0:
{
GameUnitBase unit1 = GameUserData.instance.getUnitBase(bagUI1.UserID);
short itemID = GameUserData.instance.ItemBag[itemSlot];
GameUserData.instance.removeItem(itemSlot);
unit1.addItem(itemID);
}
break;
case 2:
{
showAskUI(false);
}
break;
}
}
if (bagUI0.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI0.setItems(GameUserData.instance.getUnitBase(bagUI0.UserID).Items);
}
else
{
bagUI0.setItems(GameUserData.instance.ItemBag);
}
if (bagUI1.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI1.setItems(GameUserData.instance.getUnitBase(bagUI1.UserID).Items);
}
else
{
bagUI1.setItems(GameUserData.instance.ItemBag);
}
bagUI0.unshowItemAskUI();
bagUI0.updateItems();
bagUI1.updateItems();
bagUI1.enable(false);
bagUI0.select(bagUI0.Selection);
}
}
else
{
if (bagUI1.IsEnabledItemAskUI)
{
selection = bagUI1.SelectionItemAskUI;
uiType = bagUI1.Type;
itemSlot = bagUI1.getItemSlot();
if (uiType == GameItemBagUI.GameItemBagUIType.User)
{
GameUnitBase unit1 = GameUserData.instance.getUnitBase(bagUI1.UserID);
switch (selection)
{
case 0:
{
if (bagUI0.Type == GameItemBagUI.GameItemBagUIType.Bag)
{
short itemID = unit1.Items[itemSlot];
unit1.removeItem(itemSlot);
GameUserData.instance.addItem(itemID);
}
else
{
GameUnitBase unit0 = GameUserData.instance.getUnitBase(bagUI0.UserID);
short itemID = unit1.Items[itemSlot];
unit1.removeItem(itemSlot);
unit0.addItem(itemID);
}
}
break;
case 1:
{
if (unit1.AccessorySlot == itemSlot)
{
unit1.Accessory = GameDefine.INVALID_ID;
}
else
{
short itemID = unit1.Items[itemSlot];
GameItem item = GameItemData.instance.getData(unit1.Items[itemSlot]);
switch (item.ItemType)
{
case GameItemType.Weapon:
unit1.Weapon = itemID;
break;
case GameItemType.Armor:
unit1.Armor = itemID;
break;
case GameItemType.Accessory:
unit1.Accessory = itemID;
break;
}
}
}
break;
case 2:
{
showAskUI(false);
}
break;
}
}
else
{
switch (selection)
{
case 0:
{
GameUnitBase unit0 = GameUserData.instance.getUnitBase(bagUI0.UserID);
short itemID = GameUserData.instance.ItemBag[itemSlot];
GameUserData.instance.removeItem(itemSlot);
unit0.addItem(itemID);
}
break;
case 2:
{
showAskUI(false);
}
break;
}
}
if (bagUI0.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI0.setItems(GameUserData.instance.getUnitBase(bagUI0.UserID).Items);
}
else
{
bagUI0.setItems(GameUserData.instance.ItemBag);
}
if (bagUI1.Type == GameItemBagUI.GameItemBagUIType.User)
{
bagUI1.setItems(GameUserData.instance.getUnitBase(bagUI1.UserID).Items);
}
else
{
bagUI1.setItems(GameUserData.instance.ItemBag);
}
bagUI1.unshowItemAskUI();
bagUI1.updateItems();
bagUI0.updateItems();
bagUI0.enable(false);
bagUI1.select(bagUI1.Selection);
}
}
if (GameEquipInfoUI.instance.IsShow)
{
GameEquipInfoUI.instance.unShowFade();
}
}
protected override void OnOponentHitted(GameUnitBase unit, IBullet bullet)
{
}
protected virtual void OnOponentHitted(GameUnitBase unit, IBullet bullet)
{
unit.TakeDamage(bullet.Damage, bullet.UnitID);
}
public void updateItems()
{
clear();
updateUpDonw();
GameUnitBase unit = null;
if (type == GameItemBagUIType.User)
{
unit = GameUserData.instance.getUnitBase(userID);
}
for (int i = 0; i < MAX_SLOT; i++)
{
int index = selectionPos + i;
if (itemCount > index)
{
GameItem item = GameItemData.instance.getData(items[index]);
if (item != null)
{
if (item.ItemType == GameItemType.Item)
{
slot[i].setData(item, true, type == GameItemBagUIType.Shop);
}
else
{
slot[i].setData(item, item.canEquip(GameItemUI.instance.UserID), type == GameItemBagUIType.Shop);
}
slot[i].enable(true);
switch (type)
{
case GameItemBagUIType.Shop:
{
slot[i].enable(item.Price <= GameUserData.instance.Gold);
}
break;
case GameItemBagUIType.User:
{
if (unit.WeaponSlot == index)
{
slot[i].setEquip(true);
slot[i].enable(false);
}
if (unit.ArmorSlot == index)
{
slot[i].setEquip(true);
slot[i].enable(false);
}
if (unit.AccessorySlot == index)
{
slot[i].setEquip(true);
slot[i].enable(false);
}
}
break;
case GameItemBagUIType.Bag:
break;
case GameItemBagUIType.Count:
break;
}
}
}
}
}
public void updateData(GameUnitBase unitBase)
{
clear();
GameUnit gameUnit = GameUnitData.instance.getData(unitBase.UnitID);
short Str = unitBase.Str;
short Vit = unitBase.Vit;
short Avg = unitBase.Avg;
short Int = unitBase.Int;
short Luk = unitBase.Luk;
int hp = unitBase.HP;
int mp = unitBase.MP;
short move = (short)(Avg / 25 + gameUnit.Move);
for (int i = 0; i < (int)GameSpiritType.Count; i++)
{
powerText[i].text = GameDefine.getBigInt(unitBase.SpiritPower[i].ToString());
int f = (int)(unitBase.SpiritPower[i] / 10.0f);
if (unitBase.SpiritPower[i] % 10 > 0)
{
f += 1;
}
if (f > 10)
{
f = 10;
}
if (unitBase.SpiritPower[i] > 0)
{
power[i].showFrame(3 + f);
}
}
nameText.text = gameUnit.Name;
lvText.text = GameDefine.getBigInt(unitBase.LV.ToString());
moveText.text = GameDefine.getBigInt(move.ToString());
moveMaxText.text = GameDefine.getBigInt(move.ToString());
hpText.text = GameDefine.getBigInt(hp.ToString());
hpMaxText.text = GameDefine.getBigInt(hp.ToString());
mpText.text = GameDefine.getBigInt(mp.ToString());
mpMaxText.text = GameDefine.getBigInt(mp.ToString());
strText.text = GameDefine.getBigInt(Str.ToString());
intText.text = GameDefine.getBigInt(Int.ToString());
vitText.text = GameDefine.getBigInt(Vit.ToString());
avgText.text = GameDefine.getBigInt(Avg.ToString());
lukText.text = GameDefine.getBigInt(Luk.ToString());
// transHP.anchoredPosition = new Vector2( -2.0f , 0.0f );
// transMP.anchoredPosition = new Vector2( -2.0f , 0.0f );
}
public void levelUp(GameBattleUnit unit)
{
GameUnit gameUnit = unit.getGameUnit();
GameUnitBase unitBase = unit.getUnitBase();
GameUnitLevelUp d = getData(unitBase.UnitID);
if (d == null)
{
return;
}
if (unitBase.Exp < GameDefine.MAX_EXP)
{
return;
}
unitBase.Exp -= GameDefine.MAX_EXP;
unitBase.LV++;
if (unitBase.LV == GameDefine.MAX_LEVEL)
{
unitBase.Exp = 0;
}
lastData = new GameUnitLevelUp();
lastData.HP = gameUnit.HPGrow;
lastData.MP = gameUnit.MPGrow;
lastData.StrBase = d.StrBase;
lastData.StrRand = (short)UnityEngine.Random.Range(1, d.StrRand);
lastData.VitBase = d.VitBase;
lastData.VitRand = (short)UnityEngine.Random.Range(1, d.VitRand);
lastData.IntBase = d.IntBase;
lastData.IntRand = (short)UnityEngine.Random.Range(1, d.IntRand);
lastData.AvgBase = d.AvgBase;
lastData.AvgRand = (short)UnityEngine.Random.Range(1, d.AvgRand);
lastData.LukBase = d.LukBase;
lastData.LukRand = (short)UnityEngine.Random.Range(1, d.LukRand);
lastData.HP += (short)(unitBase.Vit / 35.0f + UnityEngine.Random.Range(1, d.HP + 1));
lastData.MP += (short)(unitBase.Int / 35.0f + UnityEngine.Random.Range(1, d.MP + 1));
unitBase.HP += lastData.HP;
unitBase.MP += lastData.MP;
unitBase.Str += lastData.StrBase;
unitBase.Str += lastData.StrRand;
unitBase.Vit += lastData.VitBase;
unitBase.Vit += lastData.VitRand;
unitBase.Int += lastData.IntBase;
unitBase.Int += lastData.IntRand;
unitBase.Avg += lastData.AvgBase;
unitBase.Avg += lastData.AvgRand;
unitBase.Luk += lastData.LukBase;
unitBase.Luk += lastData.LukRand;
unitBase.BaseSpiritPower += 2;
for (int i = 0; i < GameDefine.MAX_SLOT; i++)
{
if (d.Skill[i].SkillID == GameDefine.INVALID_ID)
{
continue;
}
if (unitBase.hasSkill(d.Skill[i].SkillID))
{
continue;
}
if (unit.SpiritPower[0] < d.Skill[i].SpiritRequest[0] ||
unit.SpiritPower[1] < d.Skill[i].SpiritRequest[1] ||
unit.SpiritPower[2] < d.Skill[i].SpiritRequest[2] ||
unit.SpiritPower[3] < d.Skill[i].SpiritRequest[3] ||
unit.SpiritPower[4] < d.Skill[i].SpiritRequest[4])
{
continue;
}
if (unit.LV < d.Skill[i].LV)
{
continue;
}
unitBase.addSkill(d.Skill[i].SkillID);
lastData.Skill[0] = new GameUnitLevelUpSkillLearn();
lastData.Skill[0].SkillID = d.Skill[i].SkillID;
}
unit.updateUnitData();
}
