private void Start()
{
myRigidbody2D = GetComponent <Rigidbody2D>();
myCollider2D = GetComponent <Collider2D>();
characterPower = GetComponent <CharacterPower>();
jumpSound = Resources.Load <AudioClip>("Sound/JumpSound");
}
public async Task <ServiceResponse <GetCharacterDto> > AddCharacterPower(AddCharacterPowerDto newPower)
{
ServiceResponse <GetCharacterDto> response = new ServiceResponse <GetCharacterDto>();
try
{
CharacterPower characterPower = _mapper.Map <CharacterPower>(newPower);
await _context.CharacterPowers.AddAsync(characterPower);
await _context.SaveChangesAsync();
Character character = await _context.Characters
.Include(cp => cp.CharacterPowers)
.ThenInclude(p => p.Power)
.FirstOrDefaultAsync(c => c.Id == newPower.CharacterId);
response.Data = _mapper.Map <GetCharacterDto>(character);
}
catch (System.Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
void Awake()
{
health = GetComponent <CharacterHealth>();
power = GetComponent <CharacterPower>();
SP = GetComponent <SpecialPower>();
teamIndicator = transform.Find("Image/CircleBlur").GetComponent <SpriteRenderer>();
}
public async Task <IHttpActionResult> LearnPower(int characterId, int power)
{
//CharacterModel characterData = await db.Characters.Select(c =>
// new CharacterModel() { Id = c.Id, Name = c.Name, MapId = c.MapId, WorldX = c.WorldX, WorldY = c.WorldY, InventoryId = c.InventoryId, Energy = (byte)c.Energy, Health = (byte)c.Health, ArmorId = c.ArmorId, LeftHandId = c.LeftHandId, RightHandId = c.RightHandId }).FirstOrDefaultAsync(c => c.Id == id); //.Include(c => c.Powers)
Character character = await db.Characters.FindAsync(characterId);
if (character == null)
{
return(NotFound());
}
int powerCount = await db.CharacterPowers.CountAsync(c => c.CharacterId == characterId);
if (powerCount >= 7)
{
return(BadRequest());
}
CharacterPower newPower = db.CharacterPowers.Create();
newPower.Power = power;
newPower.CharacterId = characterId;
db.CharacterPowers.Add(newPower);
await db.SaveChangesAsync();
return(Ok(true));
}
internal virtual void OnPerformsPower(CharacterPower characterPower)
{
if (this.PerformsPower != null)
{
PerformsPowerEventArgs eventArgs = new PerformsPowerEventArgs(characterPower);
this.PerformsPower(this, eventArgs);
}
}
internal void OnAffectedByPower(CharacterPower characterPower, Character abilityPerformedBy)
{
if (this.AffectedByPower != null)
{
AffectedByPowerEventArgs eventArgs = new AffectedByPowerEventArgs(characterPower, abilityPerformedBy);
this.AffectedByPower(this, eventArgs);
}
}
private void Start()
{
shieldPowerDrain = 1f;
myCharacterPower = GetComponent <CharacterPower>();
shieldTransform = transform.Find("Shield");
shieldTransform.gameObject.SetActive(false);
}
protected override void Initialize()
{
base.Initialize();
power = GetComponent <CharacterPower>();
powerSlider = GameManager.Instance.hudStats[character.playerIndex].powerSlider;
powerSlider.maxValue = maxPower;
powerSlider.value = 0;
}
public virtual bool PerformAbility(CharacterPower ability, Character character)
{
if (!ability.CanBePerformedBy(character))
{
return(false);
}
ability.PerformBy(this, character);
return(true);
}
private void Character_AffectedByPower(object sender, AffectedByPowerEventArgs e)
{
if (sender == null)
{
return;
}
CharacterPower power = e.CharacterPower;
ClientCharacter character = (ClientCharacter)sender;
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock<IDbSet<CharacterPower>> mockSetCharacterPowers;
var mockContext = CharacterPowersMockingSetup.DoMockingSetupForContext(false, out mockSetCharacterPowers);
var repository = new CharacterPowersRepository(mockContext.Object);
var characterPowers = new CharacterPower { Active = true, CustomKey = "SALVATORE-RAA", };
// Act
repository.Add(characterPowers);
// Assert
mockSetCharacterPowers.Verify(x => x.Add(characterPowers), Times.Once);
}
public void Verify_Add_Should_AddTheEntityToTheContext()
{
// Arrange
Mock <IDbSet <CharacterPower> > mockSetCharacterPowers;
var mockContext = CharacterPowersMockingSetup.DoMockingSetupForContext(false, out mockSetCharacterPowers);
var repository = new CharacterPowersRepository(mockContext.Object);
var characterPowers = new CharacterPower {
Active = true, CustomKey = "SALVATORE-RAA",
};
// Act
repository.Add(characterPowers);
// Assert
mockSetCharacterPowers.Verify(x => x.Add(characterPowers), Times.Once);
}
public virtual bool PerformAbility(CharacterPowerIdentity abilityId, Character character)
{
if (character == null)
{
return(false);
}
CharacterPower abilityToPerform = CharacterPower.Get(abilityId);
if (abilityToPerform == null)
{
return(false);
}
return(this.PerformAbility(abilityToPerform, character));
}
public IActionResult AddCharacter([FromBody] Character newCharacter)
{
if (ModelState.IsValid)
{
//Populate Creator, Deity, and Role from session information
newCharacter.Creator = db.Users.FirstOrDefault(id => id.UserId == 1);
// newCharacter.DeityId = HttpContext.Session.GetObjectFromJson<Deity>("Deity").DeityId;
// newCharacter.RoleId = HttpContext.Session.GetObjectFromJson<Role>("Role").RoleId;
//Populate Divine Power and Role Power in CharacterPowers table from session
// Power divinePowerJson = HttpContext.Session.GetObjectFromJson<Power>("DivinePower");
// Power rolePowerJson = HttpContext.Session.GetObjectFromJson<Power>("RolePower");
CharacterPower divineCharacterPower = new CharacterPower()
{
Character = newCharacter,
PowerId = newCharacter.DivinePower,
CurrentLevel = 1,
};
CharacterPower roleCharacterPower = new CharacterPower()
{
Character = newCharacter,
PowerId = newCharacter.RolePower,
CurrentLevel = 1,
};
db.Characters.Add(newCharacter);
db.CharacterPowers.Add(divineCharacterPower);
db.CharacterPowers.Add(roleCharacterPower);
db.SaveChanges();
return(RedirectToAction("Dashboard"));
}
List <Deity> allDeities = db.Deities.ToList();
List <Role> allRoles = db.Roles.ToList();
List <Power> allPowers = db.Powers
.OrderBy(tree => tree.SkillTreeName)
.ToList();
CharacterCreator creationView = new CharacterCreator()
{
Deities = allDeities,
Roles = allRoles,
Powers = allPowers,
};
return(View("CharacterCreation", creationView));
}
public void Update(GameTime gameTime, WorldState world)
{
foreach (CharacterPowerIdentity powerID in this.Powers)
{
var power = CharacterPower.Get(powerID);
power.Update(gameTime, world, this);
}
this.Stats.Update(gameTime);
this.Stats.Modifiers.Update(gameTime, this);
if (this.BusyDuration > 0)
{
this.BusyDuration -= gameTime.ElapsedGameTime.TotalMilliseconds;
}
if (this.IsMoving)
{
this.UpdateMapPosition(gameTime);
}
}
public void Verify_MapToEntity_WithExistingEntity_AssignsCharacterPowerProperties()
{
// Arrange
var mapper = new CharacterPowerMapper();
var model = CharacterPowersMockingSetup.DoMockingSetupForCharacterPowerModel();
// Act
ICharacterPower existingEntity = new CharacterPower {
Id = 1
};
mapper.MapToEntity(model.Object, ref existingEntity);
// Assert
// <None>
// Related Objects
Assert.Equal(model.Object.CharacterId, existingEntity.CharacterId);
Assert.Equal(model.Object.PowerId, existingEntity.PowerId);
// Associated Objects
// <None>
}
public WorldState()
{
CharacterPower.Load();
this.Projectiles = new List <ArrowColltionArea>(30);
}
private void Character_PerformsPower(object sender, PerformsPowerEventArgs e)
{
if (sender == null)
{
return;
}
CharacterPower power = e.CharacterPower;
ClientCharacter character = (ClientCharacter)sender;
switch (power.Id)
{
case CharacterPowerIdentity.DefaultAttack:
effectManager.AddEffect(new SwingEffect(this.GetScreenPostion(character.DrawPosition), this.GetScreenPostion(character.AimToPosition), character.IsEquiped(ItemIdentity.Bow)));
break;
case CharacterPowerIdentity.HardAttack:
effectManager.AddEffect(new SwingEffect(this.GetScreenPostion(character.DrawPosition), this.GetScreenPostion(character.AimToPosition), character.IsEquiped(ItemIdentity.Bow)));
break;
case CharacterPowerIdentity.CriticalAttack:
break;
case CharacterPowerIdentity.StunAttack:
break;
case CharacterPowerIdentity.SlowingAttack:
break;
case CharacterPowerIdentity.DecreaseEnergyCost:
break;
case CharacterPowerIdentity.IncreaseEnergyCost:
break;
case CharacterPowerIdentity.DecreaseDuration:
break;
case CharacterPowerIdentity.IncreaseDuration:
break;
case CharacterPowerIdentity.Meditation:
break;
case CharacterPowerIdentity.AbsorbDamage:
break;
case CharacterPowerIdentity.DeflectDamage:
break;
case CharacterPowerIdentity.ShortSpeedBurst:
break;
case CharacterPowerIdentity.IncreaseSpeed:
break;
case CharacterPowerIdentity.IncreaseMaxHealth:
break;
case CharacterPowerIdentity.IncreaseMaxEnergy:
break;
case CharacterPowerIdentity.IncreaseHealthRegen:
break;
case CharacterPowerIdentity.IncreaseEnergyRegen:
break;
case CharacterPowerIdentity.Stealth:
break;
case CharacterPowerIdentity.IncreaseSwordPower:
break;
case CharacterPowerIdentity.IncreaseBowPower:
break;
case CharacterPowerIdentity.IncreasePlateArmor:
break;
case CharacterPowerIdentity.IncreaseLeatherArmor:
break;
case CharacterPowerIdentity.IncreaseMaxWeight:
break;
case CharacterPowerIdentity.Interrupt:
break;
default:
break;
}
}
public PrepareAbility(CharacterPower abilityPrepare)
{
this.Ability = abilityPrepare;
}
public PerformsPowerEventArgs(CharacterPower characterPower)
{
this.CharacterPower = characterPower;
}
public void Verify_MapToEntity_WithExistingEntity_AssignsCharacterPowerProperties()
{
// Arrange
var mapper = new CharacterPowerMapper();
var model = CharacterPowersMockingSetup.DoMockingSetupForCharacterPowerModel();
// Act
ICharacterPower existingEntity = new CharacterPower { Id = 1 };
mapper.MapToEntity(model.Object, ref existingEntity);
// Assert
// <None>
// Related Objects
Assert.Equal(model.Object.CharacterId, existingEntity.CharacterId);
Assert.Equal(model.Object.PowerId, existingEntity.PowerId);
// Associated Objects
// <None>
}
//============================Character 呼叫===============================
//如果被敵人打到，要取得對自己的傷害
public void GetDamage(CharacterPower getDamage)
{
}
public AffectedByPowerEventArgs(CharacterPower characterPower, Character abilityPerformedBy)
{
this.characterPower = characterPower;
this.abilityPerformedBy = abilityPerformedBy;
}
