public void Record(string userId, string songId, Affinity affinity)
{
Guid userGuid = Guid.Parse(userId);
Guid songGuid = Guid.Parse(songId);
var dbAffinity = (from sa in this._context.SongAffinities
where sa.UserId == userGuid &&
sa.SongId == songGuid
select sa).FirstOrDefault();
if (dbAffinity == null)
{
dbAffinity = new DbSongAffinity
{
Id = Guid.NewGuid(),
UserId = userGuid,
SongId = songGuid,
};
this._context.SongAffinities.Add(dbAffinity);
}
dbAffinity.IsLove = affinity == Affinity.Love ? true : false;
this._context.SaveChanges();
}
public void InitFaction(string factionName, FactionType factionType, Affinity defaultAffinityInsideFaction, Affinity defaultAffinityToOtherFactions, Actor firstMemeber)
{
_Name = factionName;
_FactionType = factionType;
_defaultAffinityInsideFaction = defaultAffinityInsideFaction;
_defaultAffinityToOtherFactions = defaultAffinityToOtherFactions;
_FactionMemebers = new List <Actor>();
AddMember(firstMemeber);
}
public void Init(Affinity af)
{
BaseAffinityData afd = AssetManager.Instance.GetBaseAff(af.type);
affText.text = afd.title + ": ";
valueText.text = Math.Round(af.value, 2).ToString() + "%";
affText.color = afd.col;
valueText.color = afd.col;
}
public Player3(string name, int hp, Affinity aff,
Dictionary <Tuple <Affinity, FightTactic>, IFight> strategies)
{
_strategies = new Dictionary <Tuple <Affinity, FightTactic>, IFight>();
_initialHP = hp;
Name = name;
CurrentAffinity = aff;
HP = hp;
}
/// <summary>
/// Asks Ignite for the list of primary partitions this node is responsible for in the provided cache
/// </summary>
private bool[] GetPrimaryPartitions()
{
var result = new bool[NumPartitionsPerDataCache];
foreach (var partition in Affinity.GetPrimaryPartitions(LocalNode))
{
result[partition] = true;
}
return(result);
}
public static float GetModifier(Affinity atk, Affinity[] defs)
{
float f = 1f;
foreach (Affinity def in defs)
{
f *= GetModifier(atk, def);
}
return(f);
}
public Affinity GetAffinity(byte elements)
{
Affinity affinity = Affinity.None;
if (affinities.ContainsKey(elements))
{
affinity = affinities[elements];
}
return(affinity);
}
public Player(string name, int hp, Affinity aff, IFightFactory fsFac)
{
_initialHP = hp;
_fsFac = fsFac;
Name = name;
CurrentAffinity = aff;
HP = hp;
_currentfightStrategies = _fsFac.Create(CurrentTactics);
}
public Affinity GetAffinity(Element[] elements)
{
byte encoding = getEncoding(elements);
Affinity affinity = Affinity.None;
if (affinities.ContainsKey(encoding))
{
affinity = affinities[encoding];
}
return(affinity);
}
public static Color AffinityColor(Affinity a)
{
foreach (AffinityColor ac in instance.affinityColors)
{
if (a == ac.a)
{
return(ac.c);
}
}
return(Color.white);
}
public void SetRaceRelationshipAtoB(Race RaceA, Race RaceB, Affinity affinity)
{
int i = SearchRaceRelationship(RaceA, RaceB);
if (i == -1)
{
RaceRelationshipAtoB relationship = new RaceRelationshipAtoB(RaceA, RaceB, affinity);
}
else
{
_RaceAtoBRelationshipsList[i]._AffinityOfAtoB = affinity;
}
}
public void SetActorRelationshipAtoB(Actor actorA, Actor actorB, Affinity affinity)
{
int i = SearcActorRelationship(actorA, actorB);
if (i == -1)
{
ActorRelationshipAtoB relationship = new ActorRelationshipAtoB(actorA, actorB, affinity);
}
else
{
_ActorAtoBRelationshipsList[i]._AffinityOfAtoB = affinity;
}
}
public void SetFactionRelationshipAtoB(Faction FactionA, Faction FactionB, Affinity affinity)
{
int i = SearchFactionRelationship(FactionA, FactionB);
if (i == -1)
{
FactionRelationshipAtoB relationship = new FactionRelationshipAtoB(FactionA, FactionB, affinity);
}
else
{
_FactionAtoBRelationshipsList[i]._AffinityOfAtoB = affinity;
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Containers == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "Containers");
}
if (Affinity != null)
{
Affinity.Validate();
}
if (Containers != null)
{
foreach (var element in Containers)
{
if (element != null)
{
element.Validate();
}
}
}
if (InitContainers != null)
{
foreach (var element1 in InitContainers)
{
if (element1 != null)
{
element1.Validate();
}
}
}
if (ReadinessGates != null)
{
foreach (var element2 in ReadinessGates)
{
if (element2 != null)
{
element2.Validate();
}
}
}
if (Volumes != null)
{
foreach (var element3 in Volumes)
{
if (element3 != null)
{
element3.Validate();
}
}
}
}
public Critter(string name, float baseAttack, float baseDefense, float baseSpeed, float hp, List <Skill> moveSet, Affinity affinity)
{
affinityType = affinity;
Name = name;
if (baseAttack >= 10 && baseAttack <= 100)
{
BaseAttack = baseAttack;
}
else if (baseAttack < 10)
{
BaseAttack = 10;
}
else if (baseAttack > 100)
{
BaseAttack = 100;
}
//----
if (baseDefense >= 10 && baseDefense <= 100)
{
BaseDefense = baseDefense;
}
else if (baseAttack < 10)
{
BaseDefense = 10;
}
else if (baseDefense > 100)
{
BaseDefense = 100;
}
// ----
if (baseSpeed >= 1 && baseSpeed <= 50)
{
BaseSpeed = baseSpeed;
}
else if (baseSpeed < 1)
{
BaseSpeed = 1;
}
else if (baseSpeed > 50)
{
BaseSpeed = 50;
}
BaseSpeed = baseSpeed;
HP = hp;
MoveSet = moveSet;
}
public static float Multiplier(Affinity ownType, Affinity atkType)
{
float[,] affinityTable = new float[, ]
{
{ 0.5f, 2, 1, 1, 1, 1 },
{ 2, 0.5f, 1, 1, 1, 1 },
{ 1, 1, 0.5f, 0.5f, 1, 1 },
{ 1, 1, 2, 0.5f, 0.5f, 1 },
{ 1, 1, 1, 2, 0.5f, 2 },
{ 1, 1, 0, 1, 0.5f, 0.5f }
};
return(affinityTable[(int)ownType, (int)atkType]);
}
public Player(string name, int hp, Affinity aff)
{
_initialHP = hp;
Name = name;
CurrentAffinity = aff;
HP = hp;
_sunDefStrat = new SunFightDefensive();
_sunOffStrat = new SunFightOffensive();
_moonDefStrat = new MoonFightDefensive();
_moonOffStrat = new MoonFightOffensive();
_starsDefStrat = new StarsFightDefensive();
_starsOffStrat = new StarsFightOffensive();
}
private void ChangeAffinity()
{
if (affinity == Affinity.Null)
{
affinity = Affinity.Dark;
}
else if (affinity == Affinity.Dark)
{
affinity = Affinity.Light;
}
else if (affinity == Affinity.Light)
{
affinity = Affinity.Null;
}
}
public Thought(string topic, Topic.Stage stage, string actor, float complexity, string text,
Interrupt interruptStrategy, Turn turnStrategy, Affinity myAffinity, HashSet <string> tangents,
int eventCode, HashSet <Argument> arguments, HashSet <Emotion> emotions)
{
Topic = topic;
Stage = stage;
Actor = actor;
Complexity = complexity;
Text = text;
InterruptStrategy = interruptStrategy;
TurnStrategy = turnStrategy;
MyAffinity = myAffinity;
Tangents = tangents;
EventCode = eventCode;
Arguments = arguments;
Emotions = emotions;
}
public static void SteadyDamage(Move move, Unit user, Unit target,
DamageType type, Affinity aff = Affinity.Nu)
{
float damage = move.GetDamage();
damage *= Random.Range(0.9f, 1.1f);
bool crit = false;
bool miss = false;
target.DealDamage(damage, type, aff, crit, miss);
if (!miss)
{
user.currentEnergy += move.GetEnergyGain();
}
}
/// <summary>
/// Validate the object.
/// </summary>
/// <exception cref="Microsoft.Rest.ValidationException">
/// Thrown if validation fails
/// </exception>
public virtual void Validate()
{
if (Affinity != null)
{
Affinity.Validate();
}
if (Rules != null)
{
foreach (var element in Rules)
{
if (element != null)
{
element.Validate();
}
}
}
}
public static List <Affinity> ListToDomain(List <AffinityDTO> list_affinity)
{
List <Affinity> affinities = new List <Affinity>();
foreach (var affinity in list_affinity)
{
Affinity affinityDTO = new Affinity()
{
AffinityId = affinity.AffinityId,
Name = affinity.Name
};
affinities.Add(affinityDTO);
}
return(affinities);
}
public Critter(CritterScriptableObject critter)
{
this.img = critter.img;
this.crittername = critter.crittername;
this.baseAttack = (critter.baseAttack < 10 || critter.baseAttack > 100 ? rnd.Next(1, 101) : critter.baseAttack);
this.baseDefense = (critter.baseDefense < 10 || critter.baseDefense > 100 ? rnd.Next(1, 101) : critter.baseDefense);
this.baseSpeed = (critter.baseSpeed < 1 || critter.baseSpeed > 50 ? rnd.Next(1, 51) : critter.baseSpeed);
this.baseHP = critter.baseHP;
this.currentHP = baseHP;
//moveset
moveSet = new List <Skill>();
for (int i = 0; i < critter.moveSet.Count; i++)
{
moveSet.Add(critter.moveSet[i].getObject());
}
this.affinity = critter.affinity;
}
//Obtaining a list of affinities from Db
public List <Affinity> GetAffinities()
{
SqlCommand command = dbConnection.CreateCommand();
command.CommandText = "SELECT AffinityID,Type FROM Affinity";
SqlDataReader reader = command.ExecuteReader();
List <Affinity> affinities = new List <Affinity>();
while (reader.Read())
{
Affinity affinity = new Affinity();
affinity.AffinityID = Int32.Parse(reader.GetValue(0).ToString());
affinity.Type = reader.GetValue(1).ToString();
affinities.Add(affinity);
}
reader.Close();
return(affinities);
}
public AtkSkill(string name, float power, Affinity affinityType, int movimientos)
{
Name = name;
Movimientos = movimientos;
if (power >= 1 && power <= 10)
{
Power = power;
}
else if (power < 1)
{
Power = 1;
}
else if (power > 10)
{
Power = 10;
}
AffinitySkillType = affinityType;
}
public int GetTeamEntityLayer(Affinity affinity)
{
if (affinity == Affinity.BLUE)
{
return(blueEntityLayer);
}
else if (affinity == Affinity.RED)
{
return(redEntityLayer);
}
else if (affinity == Affinity.BROWN)
{
return(brownEntityLayer);
}
else
{
return(-1);
}
}
public int GetTeamProjectileLayer(Affinity affinity)
{
if (affinity == Affinity.BLUE)
{
return(blueProjectileLayer);
}
else if (affinity == Affinity.RED)
{
return(redProjectileLayer);
}
else if (affinity == Affinity.BROWN)
{
return(brownProjectileLayer);
}
else
{
return(-1);
}
}
public Affinity Find(Guid id)
{
Affinity affinity = null;
using (NpgsqlConnection con = new NpgsqlConnection(connectionString))
{
con.Open();
NpgsqlCommand cmd = new NpgsqlCommand();
cmd.Connection = con;
cmd.CommandText = @"SELECT * FROM affinity WHERE affinity_id=@affinity_id";
cmd.Parameters.AddWithValue("affinity_id", id.ToString());
var reader = cmd.ExecuteReader();
while (reader.Read())
{
affinity = new Affinity();
affinity.AffinityId = Guid.Parse(reader["affinity_id"].ToString());
affinity.Name = reader["name"].ToString();
}
return(affinity);
}
}
public static bool Counters(Affinity current, Affinity opponent)
{
switch (current)
{
case Affinity.Fire:
return(opponent == Affinity.Earth);
case Affinity.Earth:
return(opponent == Affinity.Water);
case Affinity.Water:
return(opponent == Affinity.Fire);
case Affinity.Light:
return(opponent == Affinity.Dark);
case Affinity.Dark:
return(opponent == Affinity.Light);
default:
return(false);
}
}
private IEnumerator DamageEffect(float amount, Affinity atkType)
{
float time, dmgTime;
time = 0;
dmgTime = 0.5f;
critterSprite.color = Color.red;
Vector3 spritePos = transform.position;
while (time <= dmgTime)
{
time += Time.deltaTime;
transform.position += new Vector3(Random.Range(-0.1f, 0.1f), Random.Range(-0.1f, 0.1f), 0);
yield return(new WaitForEndOfFrame());
}
transform.position = spritePos;
critterSprite.color = Color.white;
currentHealth -= amount * AffinityMultiplier.Multiplier(critterAf, atkType);
healtBar.sizeDelta = new Vector2(currentHealth * initialHealBarSize.x / critter.BaseHp, initialHealBarSize.y);
if (currentHealth <= 0)
{
ImDead();
}
}
public AffinityCard(Affinity a)
{
affinityf = a;
}
/// <summary>
/// 地形相性を表す記号文字を取得する
/// </summary>
public static string GetStringAffinity(Affinity aff)
{
switch (aff)
{
case Affinity.VeryGood:
return "◎";
case Affinity.Good:
return "○";
case Affinity.Normal:
return "△";
case Affinity.Bad:
default:
return "✕";
}
}
public void SetAffinity(byte elements, Affinity affinity)
{
affinities[elements] = affinity;
}
public void SetAffinity(Element[] elements, Affinity affinity)
{
byte encoding = getEncoding(elements);
affinities[encoding] = affinity;
}
