public void TearDown()
{
_avatarState = null;
_goldBalanceState = null;
_agentState = null;
_tableSheets = null;
}
public override int ValidateTransfer(AvatarState avatarState, Guid tradableId,
FungibleAssetValue price, long blockIndex)
{
var errorCode = base.ValidateTransfer(avatarState, tradableId, price, blockIndex);
if (errorCode != 0)
{
return(errorCode);
}
if (!avatarState.inventory.TryGetLockedItem(new OrderLock(OrderId), out var inventoryItem))
{
return(Buy.ErrorCodeItemDoesNotExist);
}
if (!inventoryItem.count.Equals(ItemCount))
{
return(Buy.ErrorCodeItemDoesNotExist);
}
if (inventoryItem.item is ITradableItem tradableItem)
{
return(tradableItem.ItemSubType.Equals(ItemSubType) ? errorCode : Buy.ErrorCodeInvalidItemType);
}
return(Buy.ErrorCodeItemDoesNotExist);
}
public static bool TryGetAgentAvatarStates(
this IAccountStateDelta states,
Address agentAddress,
Address avatarAddress,
out AgentState agentState,
out AvatarState avatarState
)
{
avatarState = null;
agentState = states.GetAgentState(agentAddress);
if (agentState is null)
{
return(false);
}
if (!agentState.avatarAddresses.ContainsValue(avatarAddress))
{
Log.Error(
"The avatar {0} does not belong to the agent {1}.",
avatarAddress.ToHex(),
agentAddress.ToHex()
);
return(false);
}
avatarState = states.GetAvatarState(avatarAddress);
return(!(avatarState is null));
}
public void GetArenaInfos_By_Upper_And_Lower_Range(int infoCount, int targetRank, int upperRange, int lowerRange, int expected)
{
var tableState =
TableSheets.FromTableSheetsState(TableSheetsImporter.ImportTableSheets());
var weeklyArenaState = new WeeklyArenaState(new PrivateKey().ToAddress());
Address targetAddress;
for (var i = 0; i < infoCount; i++)
{
var avatarAddress = new PrivateKey().ToAddress();
if (i + 1 == targetRank)
{
targetAddress = avatarAddress;
}
var avatarState = new AvatarState(
avatarAddress,
new PrivateKey().ToAddress(),
0L,
tableState,
new GameConfigState(),
i.ToString());
weeklyArenaState.Add(
new PrivateKey().ToAddress(),
new ArenaInfo(avatarState, tableState.CharacterSheet, true));
}
var arenaInfos = weeklyArenaState.GetArenaInfos(targetAddress, upperRange, lowerRange);
Assert.Equal(expected, arenaInfos.Count);
}
/// <summary>
/// 아바타 상태를 할당한다.
/// 로컬 세팅을 거친 상태가 최종적으로 할당된다.
/// </summary>
/// <param name="state"></param>
/// <param name="index"></param>
/// <param name="initializeReactiveState"></param>
public AvatarState AddOrReplaceAvatarState(AvatarState state, int index, bool initializeReactiveState = true)
{
if (state is null)
{
Debug.LogWarning($"[{nameof(States)}.{nameof(AddOrReplaceAvatarState)}] {nameof(state)} is null.");
return(null);
}
if (AgentState is null || !AgentState.avatarAddresses.ContainsValue(state.address))
{
throw new Exception(
$"`AgentState` is null or not found avatar's address({state.address}) in `AgentState`");
}
state = LocalLayer.Instance.Modify(state);
if (_avatarStates.ContainsKey(index))
{
_avatarStates[index] = state;
}
else
{
_avatarStates.Add(index, state);
}
return(index == CurrentAvatarKey
? SelectAvatar(index, initializeReactiveState)
: state);
}
public byte[] GenerateUpdatePacket(Context.NetworkData data, float timeOffset)
{
Profiler.BeginSample("GenerateStateUpdatePacket");
int cubeCount = Math.Min(MaxCubes, MaxStateUpdates);
context.UpdateCubePriorities();
context.GetCubeUpdates(data, ref cubeCount, ref cubeIds, ref cubes);
var header = new PacketHeader {
frame = (uint)frame,
resetId = context.resetId,
timeOffset = timeOffset
};
data.acking.AddUnackedPackets(ref header);
DetermineNotChangedAndDeltas(context, data, header.id, cubeCount, ref cubeIds, ref notChanged, ref hasDelta, ref baselineIds, ref cubes, ref cubeDeltas);
DeterminePrediction(context, data, header.id, cubeCount, ref cubeIds, ref notChanged, ref hasDelta, ref perfectPrediction, ref hasPredictionDelta, ref baselineIds, ref cubes, ref cubePredictions);
int avatarCount = 1;
localAvatar.GetComponent <Hands>().GetState(out avatars[0]);
AvatarState.Quantize(ref avatars[0], out avatarsQuantized[0]);
WriteUpdatePacket(ref header, avatarCount, ref avatarsQuantized, cubeCount, ref cubeIds, ref notChanged, ref hasDelta, ref perfectPrediction, ref hasPredictionDelta, ref baselineIds, ref cubes, ref cubeDeltas, ref cubePredictions);
var packet = writeStream.GetData();
AddPacketToDeltaBuffer(ref data.sendBuffer, header.id, context.resetId, cubeCount, ref cubeIds, ref cubes);
context.ResetCubePriority(data, cubeCount, cubeIds);
Profiler.EndSample();
return(packet);
}
public Player(AvatarState avatarState, Simulator simulator)
: base(
simulator,
simulator.TableSheets,
avatarState.characterId,
avatarState.level)
{
if (simulator is null)
{
throw new ArgumentNullException(nameof(simulator));
}
// FIXME 중복 코드 제거할 것
Exp.Current = avatarState.exp;
Inventory = avatarState.inventory;
worldInformation = avatarState.worldInformation;
weapon = null;
armor = null;
belt = null;
necklace = null;
ring = null;
monsterMap = new CollectionMap();
eventMap = new CollectionMap();
hairIndex = avatarState.hair;
lensIndex = avatarState.lens;
earIndex = avatarState.ear;
tailIndex = avatarState.tail;
PostConstruction(simulator.TableSheets);
}
public override ITradableItem Sell(AvatarState avatarState)
{
if (avatarState.inventory.TryGetTradableItems(TradableId, StartedBlockIndex, ItemCount, out List <Inventory.Item> items))
{
int totalCount = ItemCount;
// Copy ITradableFungible item for separate inventory slots.
ITradableFungibleItem copy = (ITradableFungibleItem)((ITradableFungibleItem)items.First().item).Clone();
foreach (var item in items)
{
int removeCount = Math.Min(totalCount, item.count);
ITradableFungibleItem tradableFungibleItem = (ITradableFungibleItem)item.item;
avatarState.inventory.RemoveTradableItem(TradableId, tradableFungibleItem.RequiredBlockIndex, removeCount);
totalCount -= removeCount;
if (totalCount < 1)
{
break;
}
}
// Lock item.
copy.RequiredBlockIndex = ExpiredBlockIndex;
avatarState.inventory.AddItem((ItemBase)copy, ItemCount, new OrderLock(OrderId));
return(copy);
}
throw new ItemDoesNotExistException(
$"Can't find available item in seller inventory. TradableId: {TradableId}. RequiredBlockIndex: {StartedBlockIndex}, Count: {ItemCount}");
}
public Player(
AvatarState avatarState,
CharacterSheet characterSheet,
CharacterLevelSheet characterLevelSheet,
EquipmentItemSetEffectSheet equipmentItemSetEffectSheet
) : base(
null,
characterSheet,
avatarState.characterId,
avatarState.level)
{
// FIXME 중복 코드 제거할 것
Exp.Current = avatarState.exp;
Inventory = avatarState.inventory;
worldInformation = avatarState.worldInformation;
weapon = null;
armor = null;
belt = null;
necklace = null;
ring = null;
monsterMap = new CollectionMap();
eventMap = new CollectionMap();
hairIndex = avatarState.hair;
lensIndex = avatarState.lens;
earIndex = avatarState.ear;
tailIndex = avatarState.tail;
PostConstruction(characterLevelSheet, equipmentItemSetEffectSheet);
}
public static AvatarState CreateAvatarState(string name,
Address agentAddress,
Address avatarAddress,
long blockIndex,
AvatarSheets avatarSheets,
WorldSheet worldSheet,
GameConfigState gameConfigState,
Address rankingMapAddress)
{
var avatarState = new AvatarState(
avatarAddress,
agentAddress,
blockIndex,
avatarSheets,
gameConfigState,
rankingMapAddress,
name != string.Empty ? name : "testId"
)
{
worldInformation = new WorldInformation(
0,
worldSheet,
GameConfig.RequireClearedStageLevel.ActionsInShop),
};
return(avatarState);
}
private void Update()
{
switch (state)
{
case AvatarState.Prepare:
if (inputCtrl.GetButton1Down())
{
buttonHoldTime += Time.deltaTime;
if (buttonHoldTime > prepareTime)
{
state = AvatarState.Ready;
SoundManager.Instance.Play("Effect_ControllerConfirm");
// Play confirm sound
// Update ready UI
}
}
else
{
buttonHoldTime = 0f;
}
break;
case AvatarState.Ready:
break;
}
}
private (AvatarState avatarState, AgentState agentState) CreateAvatarState(
Address agentAddress, Address avatarAddress)
{
var agentState = new AgentState(agentAddress);
var rankingMapAddress = new PrivateKey().ToAddress();
var avatarState = new AvatarState(
avatarAddress,
agentAddress,
0,
_tableSheets.GetAvatarSheets(),
new GameConfigState(),
rankingMapAddress)
{
worldInformation = new WorldInformation(
0,
_tableSheets.WorldSheet,
GameConfig.RequireClearedStageLevel.ActionsInShop),
};
agentState.avatarAddresses[0] = avatarAddress;
_sellerAgentStateMap[avatarState] = agentState;
_initialState = _initialState
.SetState(agentAddress, agentState.Serialize())
.SetState(avatarAddress, avatarState.Serialize());
return(avatarState, agentState);
}
public void ExecuteThrowNotEnoughClearedStageLevelException()
{
var avatarState = new AvatarState(_buyerAvatarState)
{
worldInformation = new WorldInformation(
0,
_tableSheets.WorldSheet,
0
),
};
_initialState = _initialState.SetState(_buyerAvatarAddress, avatarState.Serialize());
var action = new BuyMultiple
{
buyerAvatarAddress = _buyerAvatarAddress,
purchaseInfos = new List <BuyMultiple.PurchaseInfo>(),
};
Assert.Throws <NotEnoughClearedStageLevelException>(() => action.Execute(new ActionContext()
{
BlockIndex = 0,
PreviousStates = _initialState,
Random = new TestRandom(),
Signer = _buyerAgentAddress,
})
);
}
public override OrderDigest Digest2(AvatarState avatarState, CostumeStatSheet costumeStatSheet)
{
if (avatarState.inventory.TryGetTradableItem(TradableId, ExpiredBlockIndex, ItemCount,
out Inventory.Item inventoryItem))
{
ItemBase item = inventoryItem.item;
int cp = CPHelper.GetCP((ITradableItem)item, costumeStatSheet);
int level = item is Equipment equipment ? equipment.level : 0;
return(new OrderDigest(
SellerAgentAddress,
StartedBlockIndex,
ExpiredBlockIndex,
OrderId,
TradableId,
Price,
cp,
level,
item.Id,
ItemCount
));
}
throw new ItemDoesNotExistException(
$"Aborted because the tradable item({TradableId}) was failed to load from avatar's inventory.");
}
public AvatarState AddOrReplaceAvatarState(Address avatarAddress, int index, bool initializeReactiveState = true)
{
var avatarState =
new AvatarState((Bencodex.Types.Dictionary)Game.Game.instance.Agent.GetState(avatarAddress));
return(AddOrReplaceAvatarState(avatarState, index, initializeReactiveState));
}
public override void Validate(AvatarState avatarState, int count)
{
base.Validate(avatarState, count);
if (ItemCount != count)
{
throw new InvalidItemCountException(
$"Aborted because {nameof(count)}({count}) should be 1 because {nameof(TradableId)}({TradableId}) is non-fungible item.");
}
if (!avatarState.inventory.TryGetTradableItems(TradableId, StartedBlockIndex, count, out List <Inventory.Item> inventoryItems))
{
throw new ItemDoesNotExistException(
$"Aborted because the tradable item({TradableId}) was failed to load from avatar's inventory.");
}
IEnumerable <ITradableItem> tradableItems = inventoryItems.Select(i => (ITradableItem)i.item).ToList();
foreach (var tradableItem in tradableItems)
{
if (!tradableItem.ItemSubType.Equals(ItemSubType))
{
throw new InvalidItemTypeException(
$"Expected ItemSubType: {tradableItem.ItemSubType}. Actual ItemSubType: {ItemSubType}");
}
}
}
public static AvatarState CreateAvatarState(string name,
Address avatarAddress,
IActionContext ctx,
MaterialItemSheet materialItemSheet,
Address rankingMapAddress)
{
var state = ctx.PreviousStates;
var gameConfigState = state.GetGameConfigState();
var avatarState = new AvatarState(
avatarAddress,
ctx.Signer,
ctx.BlockIndex,
state.GetAvatarSheets(),
gameConfigState,
rankingMapAddress,
name
);
if (GameConfig.IsEditor)
{
var costumeItemSheet = ctx.PreviousStates.GetSheet <CostumeItemSheet>();
var equipmentItemSheet = ctx.PreviousStates.GetSheet <EquipmentItemSheet>();
AddItemsForTest(avatarState, ctx.Random, costumeItemSheet, materialItemSheet, equipmentItemSheet);
}
return(avatarState);
}
public static void Unquantize(ref AvatarStateQuantized q, out AvatarState s)
{
s.clientId = q.clientId;
s.headPosition = new Vector3(q.headPositionX, q.headPositionY, q.headPositionZ) * 1.0f / UnitsPerMeter;
SetQuaternion(out s.headRotation, q.headRotationLargest, q.headRotationX, q.headRotationY, q.headRotationZ);
s.leftHandPosition = new Vector3(q.leftHandPositionX, q.leftHandPositionY, q.leftHandPositionZ) * 1.0f / UnitsPerMeter;
s.leftHandRotation = SmallestThreeToQuaternion(q.leftHandRotationLargest, q.leftHandRotationX, q.leftHandRotationY, q.leftHandRotationZ);
s.leftHandGripTrigger = q.leftHandGripTrigger * 1.0f / MaxTrigger;
s.leftHandIdTrigger = q.leftHandIdTrigger * 1.0f / MaxTrigger;
s.isLeftHandPointing = q.isLeftHandPointing;
s.areLeftHandThumbsUp = q.areLeftHandThumbsUp;
s.isLeftHandHoldingCube = q.isLeftHandHoldingCube;
s.leftHandCubeId = q.leftHandCubeId;
s.leftHandOwnershipId = q.leftHandOwnershipSequence;
s.leftHandAuthorityId = q.leftHandAuthoritySequence;
s.leftHandCubeLocalPosition = new Vector3(q.leftHandCubeLocalPositionX, q.leftHandCubeLocalPositionY, q.leftHandCubeLocalPositionZ) * 1.0f / UnitsPerMeter;
s.leftHandCubeLocalRotation = SmallestThreeToQuaternion(q.leftHandCubeLocalRotationLargest, q.leftHandCubeLocalRotationX, q.leftHandCubeLocalRotationY, q.leftHandCubeLocalRotationZ);
s.rightHandPosition = new Vector3(q.rightHandPositionX, q.rightHandPositionY, q.rightHandPositionZ) * 1.0f / UnitsPerMeter;
s.rightHandRotation = SmallestThreeToQuaternion(q.rightHandRotationLargest, q.rightHandRotationX, q.rightHandRotationY, q.rightHandRotationZ);
s.rightHandGripTrigger = q.rightHandGripTrigger * 1.0f / MaxTrigger;
s.rightHandIdTrigger = q.rightHandIndexTrigger * 1.0f / MaxTrigger;
s.isRightHandPointing = q.isRightHandPointing;
s.areRightHandThumbsUp = q.areRightHandThumbsUp;
s.isRightHandHoldingCube = q.isRightHandHoldingCube;
s.rightHandCubeId = q.rightHandCubeId;
s.rightHandOwnershipId = q.rightHandOwnershipSequence;
s.rightHandAuthorityId = q.rightHandAuthoritySequence;
s.rightHandCubeLocalPosition = new Vector3(q.rightHandCubeLocalPositionX, q.rightHandCubeLocalPositionY, q.rightHandCubeLocalPositionZ) * 1.0f / UnitsPerMeter;
s.rightHandCubeLocalRotation = SmallestThreeToQuaternion(q.rightHandCubeLocalRotationLargest, q.rightHandCubeLocalRotationX, q.rightHandCubeLocalRotationY, q.rightHandCubeLocalRotationZ);
s.voiceAmplitude = q.voiceAmplitude * 1.0f / MaxVoice;
}
public void Show(RectTransform target, AvatarState avatarState, bool isCurrentAvatar)
{
if (isCurrentAvatar)
{
var player = Game.Game.instance.Stage.selectedPlayer;
if (player is null)
{
player = Game.Game.instance.Stage.GetPlayer();
characterView.SetByPlayer(player);
player.gameObject.SetActive(false);
}
else
{
characterView.SetByPlayer(player);
}
}
else
{
characterView.SetByAvatarAddress(avatarState.address);
}
levelText.text = $"<color=#B38271>LV.{avatarState.level}</color>";
var title = avatarState.inventory.Costumes.FirstOrDefault(costume =>
costume.ItemSubType == ItemSubType.Title &&
costume.equipped);
titleText.text = title is null
? ""
: title.GetLocalizedNonColoredName();
nameAndHashText.text = avatarState.NameWithHash;
_selectedAvatarState = avatarState;
avatarInfoButton.gameObject.SetActive(!isCurrentAvatar);
Show(new ViewModel(target));
}
private static void AddItemsForTest(
AvatarState avatarState,
IRandom random,
CostumeItemSheet costumeItemSheet,
MaterialItemSheet materialItemSheet,
EquipmentItemSheet equipmentItemSheet
)
{
foreach (var row in costumeItemSheet.OrderedList)
{
avatarState.inventory.AddItem(ItemFactory.CreateCostume(row, random.GenerateRandomGuid()));
}
foreach (var row in materialItemSheet.OrderedList)
{
avatarState.inventory.AddItem(ItemFactory.CreateMaterial(row), 10);
}
foreach (var row in equipmentItemSheet.OrderedList.Where(row =>
row.Id > GameConfig.DefaultAvatarWeaponId))
{
var itemId = random.GenerateRandomGuid();
avatarState.inventory.AddItem(ItemFactory.CreateItemUsable(row, itemId, default));
}
}
/// <summary>
/// Needed for Serialization. Not intended for use.
/// </summary>
public Speaker()
{
AvatarIndex = 0;
Message = "";
avatarState = AvatarState.Normal;
Choices = null;
}
public static (AgentState, AvatarState) GetAgentStateWithAvatarState(
IReadOnlyDictionary <string, string> sheets,
TableSheets tableSheets,
Address rankingMapAddress)
{
var agentAddress = new PrivateKey().ToAddress();
var agentState = new AgentState(agentAddress);
var avatarAddress = agentAddress.Derive("avatar");
var avatarState = new AvatarState(
avatarAddress,
agentAddress,
0,
tableSheets.GetAvatarSheets(),
new GameConfigState(sheets[nameof(GameConfigSheet)]),
rankingMapAddress)
{
worldInformation = new WorldInformation(
0,
tableSheets.WorldSheet,
Math.Max(
tableSheets.StageSheet.First?.Id ?? 1,
GameConfig.RequireClearedStageLevel.ActionsInRankingBoard)),
};
agentState.avatarAddresses.Add(0, avatarAddress);
return(agentState, avatarState);
}
public void GetRandomSeed([Values(-599628938, -1717973115, 1534786375)] int expected, [Values(1, 2, 3)] int count)
{
var avatarState = new AvatarState(
_avatarAddress,
new Address(),
0,
_tableSheets.GetAvatarSheets(),
new GameConfigState(),
new Address()
);
Assert.AreEqual(0, avatarState.Nonce);
var seed = 0;
for (var i = 0; i < count; i++)
{
seed = avatarState.GetRandomSeed();
Assert.AreEqual(i + 1, avatarState.Nonce);
}
Assert.AreEqual(expected, seed);
var random1 = new System.Random(seed);
var random2 = new System.Random(seed);
Assert.AreEqual(random1.Next(100), random2.Next(100));
Assert.AreEqual(count, avatarState.Nonce);
}
/// <summary>
/// Returns the same object as `avatarAddress` and its key among the avatar states included in `States.AvatarStates`.
/// </summary>
/// <param name="avatarAddress"></param>
/// <param name="outAvatarState"></param>
/// <param name="outKey"></param>
/// <param name="isCurrentAvatarState"></param>
/// <returns></returns>
private static bool TryGetLoadedAvatarState(
Address avatarAddress,
out AvatarState outAvatarState,
out int outKey,
out bool isCurrentAvatarState)
{
var agentState = States.Instance.AgentState;
if (agentState is null ||
!agentState.avatarAddresses.ContainsValue(avatarAddress))
{
outAvatarState = null;
outKey = -1;
isCurrentAvatarState = false;
return(false);
}
foreach (var pair in States.Instance.AvatarStates)
{
if (!pair.Value.address.Equals(avatarAddress))
{
continue;
}
outAvatarState = pair.Value;
outKey = pair.Key;
isCurrentAvatarState = outKey.Equals(States.Instance.CurrentAvatarKey);
return(true);
}
outAvatarState = null;
outKey = -1;
isCurrentAvatarState = false;
return(false);
}
public RewardGoldTest()
{
var sheets = TableSheetsImporter.ImportSheets();
sheets[nameof(CharacterSheet)] = string.Join(
Environment.NewLine,
"id,_name,size_type,elemental_type,hp,atk,def,cri,hit,spd,lv_hp,lv_atk,lv_def,lv_cri,lv_hit,lv_spd,attack_range,run_speed",
"100010,전사,S,0,300,20,10,10,90,70,12,0.8,0.4,0,3.6,2.8,2,3");
var privateKey = new PrivateKey();
var agentAddress = privateKey.PublicKey.ToAddress();
var avatarAddress = agentAddress.Derive("avatar");
_tableSheets = new TableSheets(sheets);
_avatarState = new AvatarState(
avatarAddress,
agentAddress,
0,
_tableSheets.GetAvatarSheets(),
new GameConfigState(),
default
);
var gold = new GoldCurrencyState(new Currency("NCG", 2, minter: null));
_baseState = (State) new State()
.SetState(GoldCurrencyState.Address, gold.Serialize())
.SetState(Addresses.GoldDistribution, GoldDistributionTest.Fixture.Select(v => v.Serialize()).Serialize())
.MintAsset(GoldCurrencyState.Address, gold.Currency * 100000000000);
}
public static bool TryGetAgentAvatarStatesV2(
this IAccountStateDelta states,
Address agentAddress,
Address avatarAddress,
out AgentState agentState,
out AvatarState avatarState
)
{
avatarState = null;
agentState = states.GetAgentState(agentAddress);
if (agentState is null)
{
return(false);
}
if (!agentState.avatarAddresses.ContainsValue(avatarAddress))
{
throw new AgentStateNotContainsAvatarAddressException(
$"The avatar {avatarAddress.ToHex()} does not belong to the agent {agentAddress.ToHex()}.");
}
try
{
avatarState = states.GetAvatarStateV2(avatarAddress);
}
catch (FailedLoadStateException)
{
// BackWardCompatible.
avatarState = states.GetAvatarState(avatarAddress);
}
return(!(avatarState is null));
}
public StageSimulator(
IRandom random,
AvatarState avatarState,
List <Guid> foods,
int worldId,
int stageId,
TableSheets tableSheets) : base(random, avatarState, foods, tableSheets)
{
_waves = new List <Wave>();
WorldId = worldId;
StageId = stageId;
IsCleared = avatarState.worldInformation.IsStageCleared(StageId);
var stageSheet = TableSheets.StageSheet;
if (!stageSheet.TryGetValue(StageId, out var stageRow))
{
throw new SheetRowNotFoundException(nameof(stageSheet), StageId);
}
var stageWaveSheet = TableSheets.StageWaveSheet;
if (!stageWaveSheet.TryGetValue(StageId, out var stageWaveRow))
{
throw new SheetRowNotFoundException(nameof(stageWaveSheet), StageId);
}
Exp = StageRewardExpHelper.GetExp(avatarState.level, stageId);
TurnLimit = stageRow.TurnLimit;
SetWave(stageRow, stageWaveRow);
_waveRewards = SetReward(stageRow, random, tableSheets);
}
public void GetRankingInfos()
{
var state = new RankingMapState(_rankingMapAddress);
for (var i = 0; i < 10; i++)
{
var avatarState = new AvatarState(
_agentAddress.Derive(i.ToString()),
_agentAddress,
0,
_tableSheets.GetAvatarSheets(),
new GameConfigState(),
_rankingMapAddress,
"test"
)
{
exp = 10 - i,
};
state.Update(avatarState);
}
var list = state.GetRankingInfos(null);
for (var index = 0; index < list.Count; index++)
{
var info = list[index];
Assert.Equal(10 - index, info.Exp);
Assert.Equal(_agentAddress.Derive(index.ToString()), info.AvatarAddress);
}
}
public static bool TryGetAvatarState(
this IAccountStateDelta states,
Address agentAddress,
Address avatarAddress,
out AvatarState avatarState
)
{
avatarState = null;
var value = states.GetState(avatarAddress);
if (value is null)
{
return(false);
}
try
{
var serializedAvatar = (Dictionary)value;
if (serializedAvatar["agentAddress"].ToAddress() != agentAddress)
{
return(false);
}
avatarState = new AvatarState(serializedAvatar);
return(true);
}
catch (InvalidCastException)
{
return(false);
}
catch (KeyNotFoundException)
{
return(false);
}
}
/// <summary>
/// Add a new Speaker to a Conversation
/// </summary>
/// <param name="avatar">Avatar Index for Speaker</param>
/// <param name="msg">Speaker's Message</param>
public Speaker(int avatar, string msg, AvatarState state, Dictionary<string, int> choices)
{
AvatarIndex = avatar;
Message = msg;
avatarState = state;
Choices = choices;
}
public void Update()
{
var avatarAddress = _agentAddress.Derive("avatar");
var rankingMapAddress = avatarAddress.Derive("ranking_map");
var avatarState = new AvatarState(
avatarAddress,
_agentAddress,
0,
_tableSheets.GetAvatarSheets(),
new GameConfigState(),
rankingMapAddress,
"test"
);
var state = new RankingMapState(rankingMapAddress);
state.Update(avatarState);
Assert.Single(state.GetRankingInfos(null));
Assert.Equal(0, state.GetRankingInfos(null).First().Exp);
avatarState.exp += 100;
state.Update(avatarState);
Assert.Single(state.GetRankingInfos(null));
Assert.Equal(100, state.GetRankingInfos(null).First().Exp);
}
/// <summary>
/// Do not use anymore since v100025.
/// </summary>
public StageSimulator(
IRandom random,
AvatarState avatarState,
List <Guid> foods,
int worldId,
int stageId,
StageSimulatorSheets stageSimulatorSheets,
Model.Skill.Skill skill
)
: this(
random,
avatarState,
foods,
worldId,
stageId,
stageSimulatorSheets
)
{
var stageSheet = stageSimulatorSheets.StageSheet;
if (!stageSheet.TryGetValue(StageId, out var stageRow))
{
throw new SheetRowNotFoundException(nameof(stageSheet), StageId);
}
Exp = StageRewardExpHelper.GetExp(avatarState.level, stageId);
TurnLimit = stageRow.TurnLimit;
if (!ReferenceEquals(skill, null))
{
Player.OverrideSkill(skill);
}
}
/// <summary>If player is disabled, use this to return movement to the player.</summary>
public void Enable()
{
State = AvatarState.Standing;
}
void PlayerGetsHit()
{
if (PlayerStop)
{
if (count < 10)
{
PlayerModel.Link.Position.Y += mPhysics.Peek.gravity;
if (PlayerModel.Link.Position.X < enemyX)
{
PlayerModel.Link.Position.X -= 1f;
}
else
{
PlayerModel.Link.Position.X += 1f;
}
}
else
{
if (!mPhysics.Peek.Top)
{
PlayerModel.Link.Position.Y += mPhysics.Peek.gravity;
if (PlayerModel.Link.Position.X < enemyX)
{
PlayerModel.Link.Position.X -= 1f;
}
else
{
PlayerModel.Link.Position.X += 1f;
}
}
else
{
PlayerStop = false;
}
}
count++;
}
else
{
PlayerHit = true;
PlayerHitTimer = 0;
State = AvatarState.Standing;
}
}
void Movement()
{
if (State != AvatarState.AttackingLight && State != AvatarState.AttackingHeavy && State != AvatarState.Ability)
{
if ((!FlipControls && !mInput.Peek.IsKeyPressed(Keys.A) && !mInput.Peek.IsKeyPressed(Keys.S) && !mInput.Peek.IsKeyPressed(Keys.D) && !mInput.Peek.IsKeyPressed(Keys.W)) ||
(FlipControls && !mInput.Peek.IsKeyPressed(Keys.Right) && !mInput.Peek.IsKeyPressed(Keys.Left) && !mInput.Peek.IsKeyPressed(Keys.Down) && !mInput.Peek.IsKeyPressed(Keys.Up)))
{
Move = Vector3.Zero;
if (State != AvatarState.Ability && State != AvatarState.Jumping)
State = AvatarState.Standing;
}
if (State != AvatarState.Hit &&(((FlipControls) && (!mInput.Peek.IsKeyDown(Keys.Down)) && (mInput.Peek.IsKeyDown(Keys.Up))) || ((!FlipControls) && (!mInput.Peek.IsKeyDown(Keys.S)) && (mInput.Peek.IsKeyDown(Keys.W)))))//Move Up
{
if (State != AvatarState.Jumping)
{
State = AvatarState.Walking;
}
Move.Z--;
}
if (State != AvatarState.Hit &&(((FlipControls) && (!mInput.Peek.IsKeyDown(Keys.Up)) && (mInput.Peek.IsKeyDown(Keys.Down))) || ((!FlipControls) && (!mInput.Peek.IsKeyDown(Keys.Up)) && (!mInput.Peek.IsKeyDown(Keys.W)) && (mInput.Peek.IsKeyDown(Keys.S)))))//Move Down
{
if (State != AvatarState.Jumping)
{
State = AvatarState.Walking;
}
Move.Z++;
}
if (State != AvatarState.Hit &&(((FlipControls) && (!mInput.Peek.IsKeyDown(Keys.Right)) && (mInput.Peek.IsKeyDown(Keys.Left))) || ((!FlipControls) && (!mInput.Peek.IsKeyDown(Keys.D)) && (mInput.Peek.IsKeyDown(Keys.A)))))//Move Left
{
PlayerModel.Link.HorizontalTextureFlip = true;
FaceingRight = false;
if (State != AvatarState.Jumping)
{
State = AvatarState.Walking;
}
Move.X--;
}
if (State != AvatarState.Hit &&(((FlipControls) && (!mInput.Peek.IsKeyDown(Keys.Left)) && (mInput.Peek.IsKeyDown(Keys.Right))) || ((!FlipControls) && (!mInput.Peek.IsKeyDown(Keys.A)) && (mInput.Peek.IsKeyDown(Keys.D)))))//Move Right
{
PlayerModel.Link.HorizontalTextureFlip = false;
FaceingRight = true;
if (State != AvatarState.Jumping)
{
State = AvatarState.Walking;
}
Move.X++;
}
}
}
// Player's input
void Input()
{
if (mInput.Peek.IsKeyPressed(Keys.F3))
{
//if (FlipControls)
// FlipControls = false;
//else
// FlipControls = true;
StunPlayer(600);
}
//Input check (not final)
if (State != AvatarState.Talking && !Stun)
{
#region Defend
if ((((FlipControls) && (mInput.Peek.IsKeyDown(Keys.S))) || ((!FlipControls) && (mInput.Peek.IsKeyDown(Keys.Down)))))
{
if ((mPhysics.Peek.gravity == 0) && (State != AvatarState.Hit) && (State != AvatarState.Jumping) && (State != AvatarState.AttackingLight) && (State != AvatarState.AttackingHeavy) && (State != AvatarState.Falling))
{
Move = Vector3.Zero;
Defending = true;
PlayerModel.Link.Texture = t2d_AvatarDefend;
}
}
else
{
if (Defending)
{
State = AvatarState.Standing;
Defending = false;
}
}
#endregion
if (!Defending)
{
if (State != AvatarState.Hit)
{
#region LightAttack
if (((FlipControls) && (mInput.Peek.IsKeyPressed(Keys.A))) || ((!FlipControls) && (mInput.Peek.IsKeyPressed(Keys.Left))))
{
if ((State != AvatarState.Jumping) && (State != AvatarState.AttackingLight) && (State != AvatarState.AttackingHeavy) && (State != AvatarState.Falling))
{
mAudio.Peek.PlaySound(mAudio.SoundName.LightAttack);
AttackAlive = true;
Damage = 8;
State = AvatarState.AttackingLight;
count = 0;
AttackBox.Link.Position = PlayerModel.Link.Position;
Move = Vector3.Zero;
RegenStart = 0;
}
}
if (State == AvatarState.AttackingLight)
{
if (count < 20)
{
if (FaceingRight)
{
AttackBox.Link.Position.X += .3f;
}
else
{
AttackBox.Link.Position.X -= .3f;
}
count++;
}
else
{
for (int i = 0; i < mAI.Peek.enemyList.Count; i++)
{
mAI.Peek.enemyList[i].Hit = false;
}
State = AvatarState.Standing;
AttackAlive = false;
}
}
#endregion
#region HeavyAttack
if (((FlipControls) && (mInput.Peek.IsKeyPressed(Keys.D))) || ((!FlipControls) && (mInput.Peek.IsKeyPressed(Keys.Right))))
{
if ((State != AvatarState.Jumping) && (State != AvatarState.AttackingLight) && (State != AvatarState.AttackingHeavy) && (State != AvatarState.Falling))
{
mAudio.Peek.PlaySound(mAudio.SoundName.HeavyAttack);
AttackAlive = true;
Damage = 12;
Move = Vector3.Zero;
RegenStart = 0;
if (FaceingRight)
{
AttackBox.Link.Position = new Vector3(PlayerModel.Link.Position.X - 10, PlayerModel.Link.Position.Y, PlayerModel.Link.Position.Z - 10);
ArcChange = 1;
}
else
{
AttackBox.Link.Position = new Vector3(PlayerModel.Link.Position.X + 10, PlayerModel.Link.Position.Y, PlayerModel.Link.Position.Z - 10);
ArcChange = -1;
}
State = AvatarState.AttackingHeavy;
count = 0;
}
}
if (State == AvatarState.AttackingHeavy)
{
if (count < 40)
{
if (AttackBox.Link.Position.Z > PlayerModel.Link.Position.Z)
{
if (FaceingRight)
{
ArcChange = -.5f;
}
else
{
ArcChange = .5f;
}
}
AttackBox.Link.Position += new Vector3(ArcChange, 0f, .5f);
count++;
}
else
{
for (int i = 0; i < mAI.Peek.enemyList.Count; i++)
{
mAI.Peek.enemyList[i].Hit = false;
}
State = AvatarState.Standing;
AttackAlive = false;
}
}
#endregion
#region Jump
if (mInput.Peek.IsKeyPressed(Keys.Space))
{
if ((State != AvatarState.Jumping) && (State != AvatarState.AttackingHeavy) && (State != AvatarState.AttackingLight) && State != AvatarState.Ability && mPhysics.Peek.Top)
{
if (!mPhysics.Peek.jump)
{
mAudio.Peek.PlaySound(mAudio.SoundName.Jump);
mPhysics.Peek.SetGravity(2.0f);
mPhysics.Peek.jump = true;
State = AvatarState.Jumping;
}
}
}
if (State == AvatarState.Jumping)
{
if (mPhysics.Peek.gravity > 0)
{
PlayerModel.Link.Position.Y += mPhysics.Peek.GetGravity();
}
if (!mPhysics.Peek.jump)
{
State = AvatarState.Standing;
speed = WalkSpeed;
}
}
#endregion
#region Ability
switch (Ability)
{
case abilityState.None:
break;
case abilityState.Alice:
if (((FlipControls) && (mInput.Peek.IsKeyPressed(Keys.W))) || ((!FlipControls) && (mInput.Peek.IsKeyPressed(Keys.Up))))
{
if ((State != AvatarState.Jumping) && (State != AvatarState.Falling) && (State != AvatarState.Ability) && iCurrentInk > 15)
{
mAudio.Peek.PlaySound(mAudio.SoundName.SpecialOnOff);
InkAdd(-15);
AttackAlive = true;
Move = Vector3.Zero;
State = AvatarState.Ability;
count = 0;
AttackBox.Link.Position = PlayerModel.Link.Position;
}
}
if (State == AvatarState.Ability)
{
if (count < 25)
{
if (FaceingRight)
{
AttackBox.Link.Position.X += .2f;
}
else
{
AttackBox.Link.Position.X -= .2f;
}
count++;
}
else
{
for (int i = 0; i < mAI.Peek.enemyList.Count; i++)
{
mAI.Peek.enemyList[i].Hit = false;
}
State = AvatarState.Standing;
AttackAlive = false;
}
}
break;
}
#endregion
Movement();
Check();
EnemyCollision();
}
else
{
PlayerGetsHit();
}
}
}
else
{
if (mPhysics.Peek.gravity > 0)
{
PlayerModel.Link.Position.Y += mPhysics.Peek.GetGravity();
}
if (Stun && State == AvatarState.Hit)
{
PlayerGetsHit();
}
Check();
}
}
/// <summary>This stuns the player so he can not take any action but still get hit, Duration is in milliseaconds </summary><param name="DurationMilliseconds"></param>
public void StunPlayer(float Duration)
{
Stun = true;
StunDuration = Duration;
Move = Vector3.Zero;
State = AvatarState.Standing;
AttackAlive = false;
Defending = false;
PlayerModel.Link.Texture = t2d_AvatarStun;
}
/// <summary>Load the player's content,put me where you load everything. pass it the position of where the player will start</summary><param name="Position"></param>
public void Load(Vector3 Position)
{
mAnimation.Peek.Load();
mDamage.Peek.Load();
State = AvatarState.Standing;
PlayerHit = false;
PlayerStop = false;
PlayerHitTimer = 0;
FaceingRight = true;
shadowBox = new BasicModel(Engine.GameContainer, ModelProperties.Alpha, "Models\\Basic Objects\\ShadowPlane", Position - new Vector3(0, 50, 0));
PlayerModel = new BasicModel(Engine.GameContainer, ModelProperties.Alpha, "Models\\Planes\\Plane6", Position);
PlayerModel.Link.BoundingBox.Min += Engine.TempVector3(5, 0, -1f);
PlayerModel.Link.BoundingBox.Max += Engine.TempVector3(-5.5f, -3, 1f);
AttackBox = new BasicModel(Engine.GameContainer, ModelProperties.Alpha, "Models\\Basic Objects\\box", Vector3.Zero);
AttackBox.Link.Display = false;
PlayerModel.Link.Position = Position;
t2d_AvatarDefend = Engine.GameContainer.Load<Texture2D>("Textures\\Animations\\Character\\heroDefend0");
t2d_AvatarStun = Engine.GameContainer.Load<Texture2D>("Textures\\Environment\\Ground\\Grass");
AttackBox.Link.BoundingBox.Max -= Engine.TempVector3(2, 3, -.5f);
AttackBox.Link.BoundingBox.Min += Engine.TempVector3(3, 3, -.5f);
shadowBox.Link.BoundingBox = PlayerModel.Link.BoundingBox;
shadowBox.Link.Texture = Engine.GameContainer.Load<Texture2D>("Textures\\Animations\\Character\\ShadowPlane");
SetBounds(-1000, 1000, -1000, 1000, -1000, 1000);
}
/// <summary>Bring the player back to full ink and health</summary>
public void FullRestore()
{
State = AvatarState.Standing;
PlayerHit = false;
PlayerStop = false;
PlayerHitTimer = 0;
FaceingRight = true;
iCurrentHealth = iMaxHealth;
iCurrentInk = iMaxInk;
}
/// <summary>Stop the player's actions</summary>
public void Disable()
{
Move = Vector3.Zero;
State = AvatarState.Talking;
}
public AvatarStateEventArgs(AvatarState state)
{
this.state = state;
}
/// <summary>This is to hit the player so that the player will be pushed backed and gave invincibility time
/// PosX is the X position of what hit the player, its for direction of push back
/// Damage should be how much damage should be delt to the player.</summary><param name="PosX"></param><param name="damage"></param>
public void HitPlayer(float PosX, int damage)
{
if (State != AvatarState.Hit && !PlayerHit)
{
Move = Vector3.Zero;
mPhysics.Peek.SetGravity(1);
HealthAdd(-damage);
enemyX = PosX;
State = AvatarState.Hit;
count = 0;
PlayerStop = true;
RegenStart = 0;
for (int i = 0; i < mAI.Peek.enemyList.Count; i++)
{
mAI.Peek.enemyList[i].Hit = false;
}
AttackAlive = false;
}
if (Defending)
{
if (PlayerModel.Link.Position.X < enemyX)
{
PlayerModel.Link.Position.X -= 5f;
}
else
{
PlayerModel.Link.Position.X += 5f;
}
}
}
