public override void OnPrismChange(MagicColor mode)
{
if ((magicColor & mode) != 0)
{
BecomeInteractable();
switch (mode)
{
case MagicColor.Red:
spriteRenderer.color = Color.red;
break;
case MagicColor.Green:
spriteRenderer.color = Color.green;
break;
case MagicColor.Blue:
spriteRenderer.color = Color.blue;
break;
}
}
else
{
RefreshColor();
BecomeNotInteractable();
}
}
public void ChangeTo(MagicColor mode)
{
if (currerntMode == mode)
return;
transSE.Play();
foreach (MagicObject mo in magicObjectList)
{
mo.OnPrismChange(mode);
}
switch (mode)
{
case MagicColor.Red:
swapAnim.SetTrigger(toRedId);
break;
case MagicColor.Green:
swapAnim.SetTrigger(toGreenId);
break;
case MagicColor.Blue:
swapAnim.SetTrigger(toBlueId);
break;
}
PushPlayer();
if (playerCam.state == CameraState.Normal)
playerCam.FixByPrism(playerCam.transform.position);
currerntMode = mode;
}
public void Initialize(MagicColor color)
{
this.color = color;
ColoredPart.ChangeColor(color);
StartCoroutine(growRoutine());
}
public void Start()
{
MagicColor color = (MagicColor)Random.Range(0, 3);
Gem.ColorPart.ChangeColor(color);
Health.Color = color;
transform.position = EnemySpawner.Instance.HamsterSpawnLocations.GetNext().position;
rb = GetComponent <Rigidbody2D>();
animator = GetComponent <Animator>();
StartCoroutine(startRoutine());
Health.Death.AddListener(() => {
Gem.Launch();
currentSpeed = DeathSpeed;
if (RandomExtra.Chance(.5f))
{
currentSpeed *= -1;
}
StopAllCoroutines();
GetComponent <Collider2D>().enabled = false;
GetComponent <DestroyWhenChildrenInvisible>().ShouldDestroy = true;
});
}
public override void OnPrismChange(MagicColor mode)
{
if (mode == magicColor)
spriteRenderer.enabled = true;
else
spriteRenderer.enabled = false;
}
public override void OnPrismChange(MagicColor mode)
{
base.OnPrismChange(mode);
//指定分離出來的物體的速度，因為我發現Instantiate複製出來的物體，在物理引擎裡面的速度不會保留，所以要重新指定。
if (detachedObj != null)
detachedObj.GetComponent<Rigidbody2D>().velocity = rb.velocity;
}
public void ChangeColor(MagicColor color)
{
Color = color;
var m = ParticleSystem.main;
m.startColor = MagicColorStats.ColorMap[Color];
}
public void Remove(MagicColor magiccolor)
{
using (var session = NHibernateHelper.OpenSession())
using (var transaction = session.BeginTransaction())
{
session.Delete(magiccolor);
transaction.Commit();
}
}
// 用户自定义编辑颜色（添加颜色之后应该同步修改块儿的记录）（编辑颜色要判断颜色的个数是否过多和组合是否重复）
public void SetEditColor(MagicColor pickedcolor)
{
operater.ColorDelete (mycolor);
this.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [pickedcolor];
mycolor = pickedcolor;
operater.ColorAdd ();
cube.SetColor (this.gameObject);
}
public void Initialize(MagicColor color)
{
this.color = color;
for (int i = 0; i < Clouds; i++)
{
spawnCloud();
}
}
// 用户自定义编辑颜色（添加颜色之后应该同步修改块儿的记录）（编辑颜色要判断颜色的个数是否过多和组合是否重复）
public void SetEditColor(MagicColor pickedcolor)
{
operater.ColorDelete(mycolor);
this.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [pickedcolor];
mycolor = pickedcolor;
operater.ColorAdd();
cube.SetColor(this.gameObject);
}
public override void RandomizePointColors()
{
foreach (var triangle in _triangles)
{
foreach (var point in triangle.GetPoints())
{
point.Color = MagicColor.GetRandomColor();
}
}
}
public override void RandomizePointColors()
{
foreach (var penLine in _penLines)
{
foreach (var point in penLine.GetPoints())
{
point.Color = MagicColor.GetRandomColor();
}
}
}
public void Initialize(bool goingLeft, MagicColor color)
{
base.Initialize(color);
rb.velocity = new Vector2
(
LaunchSpeed.x * (goingLeft ? -1 : 1),
LaunchSpeed.y
);
destroyInvisible = GetComponent <DestroyWhenChildrenInvisible>();
}
void Awake()
{
SingletonSetInstance(this, true);
CoinMask.fillAmount = 1;
colors = new ColorBag();
colors.Items = new List <MagicColor> {
MagicColor.Red, MagicColor.Green, MagicColor.Blue
};
colors.AvoidRepeats = true;
currentColor = colors.GetNext();
}
MagicColor getColor()
{
colorStreak++;
var chance = ChanceToSwitchColorsByColorStreak.Evaluate(colorStreak);
if (RandomExtra.Chance(chance))
{
currentColor = colors.GetNext();
colorStreak = 0;
}
return(currentColor);
}
// uses c# compare convention to define greater-than relation. semantically, if x > y, then x is super effective against y and y is weak against x; if x == y, then x and y have neutral effects with one another
public static int Compare(this MagicColor x, MagicColor y)
{
// from https://stackoverflow.com/a/9553712/5931898
int d = (3 + y - x) % 3;
if (d == 2)
{
return(-1);
}
else
{
return(d);
}
}
public override void OnPrismChange(MagicColor mode)
{
if ((mode & magicColor) != MagicColor.None)
{
col.isTrigger = false;
spriteRenderer.enabled = true;
anim.SetBool(appearId, true);
}
else
{
col.isTrigger = true;
spriteRenderer.enabled = false;
anim.SetBool(appearId, false);
}
}
public void ClosePrism()
{
if (currerntMode == MagicColor.White)
return;
transSE.Play();
currerntMode = MagicColor.White;
swapAnim.SetTrigger(toWhiteId);
foreach (MagicObject mo in magicObjectList)
{
mo.OnPrismClose();
}
if (playerCam.state == CameraState.FixedByPrism)
playerCam.ReleaseCam();
PushPlayer();
}
public void SetColor(GameObject p)
{
bool cansetcolor = true;
if (operater == null)
{
operater = FindObjectOfType <MagicCubeOperate> ();
}
MagicColor curcolor = operater.EditColor;
if (cubecolor.ContainsKey(p))
{
foreach (GameObject g in cubecolor.Keys)
{
if (g != p)
{
if (!cubecolor [g].Equals(MagicColor.None))
{
if (cubecolor [g] == curcolor)
{
cansetcolor = false;
break;
}
int index = (int)curcolor;
if (index >= 3 && (int)cubecolor [g] == index - 3)
{
cansetcolor = false;
break;
}
else if (index < 3 && (int)cubecolor [g] == index + 3)
{
cansetcolor = false;
break;
}
}
}
}
if (cansetcolor)
{
p.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [curcolor];
cubecolor [p] = curcolor;
}
}
}
public void Initialize(HamsterFart parent, Vector2 velocity, MagicColor color)
{
this.parent = parent;
ColorPart.ChangeColor(color);
bool use1 = RandomExtra.Chance(.5f);
Outline.sprite = use1 ? Outline1 : Outline2;
Cloud.sprite = use1 ? Cloud1 : Cloud2;
Outline.SetAlpha(Alpha);
Cloud.SetAlpha(Alpha);
GetComponent <Collider2D>().isTrigger = true; // just in case
GetComponent <Rigidbody2D>().velocity = velocity;
Destroy(gameObject, RandomExtra.Range(LifeTimeRange));
}
MagicColor _getTeamMate(bool next)
{
MagicColor col = MageSquad.Instance.ActiveMage.Color;
switch (col)
{
case MagicColor.Red:
return(next ? MagicColor.Green : MagicColor.Blue);
case MagicColor.Green:
return(next ? MagicColor.Blue : MagicColor.Red);
case MagicColor.Blue:
return(next ? MagicColor.Red : MagicColor.Green);
default:
throw new Exception($"unexpected active mage color {col}");
}
}
public void CanAddColor()
{
var color = new MagicColor {
Name = "Green", ShortName = "G"
};
IMagicColorsRepository repository = new MagicColorsRepository();
repository.Add(color);
// use session to try to load the product);
using (ISession session = _sessionFactory.OpenSession())
{
var fromDb = session.Get <MagicColor>(color.Id);
// Test that the color was successfully inserted
Assert.IsNotNull(fromDb);
Assert.AreNotSame(color, fromDb);
Assert.AreEqual(color.Name, fromDb.Name);
Assert.AreEqual(color.ShortName, fromDb.ShortName);
}
}
public void ColorDamage(float damage, MagicColor color)
{
if (!IsColored)
{
PureDamage(damage);
return;
}
float dam = damage;
switch (color.Compare(Color))
{
case -1:
dam *= MagicColorStats.WeakDamage;
break;
case 1:
dam *= MagicColorStats.SuperEffectiveDamage;
break;
}
CurrentHealth -= dam;
}
public void ChangeColor(MagicColor color)
{
Color = color;
GetComponent <Graphic>().color = MagicColorStats.ColorMap[Color];
}
// 根据位置来设置面片的颜色，适用于自动重新设置魔方颜色
public void SetDefaultColor()
{
this.mycolor = MyMapPrefab.StyleColorMap [facestyle];
this.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [MyMapPrefab.StyleColorMap [facestyle]];
}
public void SetEditColor()
{
EditColorStore.Clear ();
EditColorStore.Add (MagicColor.White, 0);
EditColorStore.Add (MagicColor.Red, 0);
EditColorStore.Add (MagicColor.Yellow, 0);
EditColorStore.Add (MagicColor.Green, 0);
EditColorStore.Add (MagicColor.Blue, 0);
EditColorStore.Add (MagicColor.Orange, 0);
EditColorStore.Add (MagicColor.None, 0);
curColor = MagicColor.None;
for (int i = 0; i < cubefaces.Length; i++) {
if (cubefaces [i].cube.cubestyle.Equals (CubeStyle.Face)) {
cubefaces [i].UpdateFaceStyle ();
cubefaces [i].SetDefaultColor ();
} else {
cubefaces [i].SetEditColor (MagicColor.None);
}
}
}
// 拾取颜色
public void PickColor(MagicColor col)
{
curColor = col;
print (curColor);
}
public void ColorDelete(MagicColor color)
{
if (color != MagicColor.None) {
EditColorStore [color] -= 1;
}
}
// 用户自定义编辑颜色（添加颜色之后应该同步修改块儿的记录）（编辑颜色要判断颜色的个数是否过多和组合是否重复）
public void SetMapColor(MagicColor c)
{
this.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [c];
mycolor = c;
}
// 拾取颜色
public void PickColor(MagicColor col)
{
curColor = col;
}
// 拾取颜色
public void PickColor(MagicColor col)
{
curColor = col;
}
public virtual void Initialize(MagicColor color)
{
Visuals.Color = color;
rb = GetComponent <Rigidbody2D>();
}
/// <summary>
/// Set random color for this pixel
/// </summary>
public void SetRandomColor()
{
Color = MagicColor.GetRandomColor();
}
public void Initialize(Vector2 direction, MagicColor color)
{
base.Initialize(color);
rb.velocity = direction.normalized * Speed;
}
public override void OnPrismChange(MagicColor mode)
{
spriteRenderer.enabled = false;
}
// 根据位置来设置面片的颜色，适用于自动重新设置魔方颜色
public void SetDefaultColor()
{
this.mycolor = MyMapPrefab.StyleColorMap [facestyle];
this.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [MyMapPrefab.StyleColorMap [facestyle]];
}
public void Initialize(bool goingLeft, MagicColor color)
{
base.Initialize(color);
rb.velocity = (goingLeft ? Vector3.left : Vector3.right) * Speed;
}
public void ChangeColor(MagicColor color)
{
Color = color;
sr.color = MagicColorStats.ColorMap[Color];
}
public void SetColor(MagicColor color)
{
var m = ParticleSystem.main;
m.startColor = MagicColorStats.ColorMap[color];
}
// public void InitColor ()
// {
// SingleBoxPiece[] mypieces = GetComponentsInChildren <SingleBoxPiece> ();
// cubecolor.Clear ();
// foreach (SingleBoxPiece p in mypieces) {
// p.GetComponent <MeshRenderer> ().material.color = Color.gray;
// cubecolor.Add (p.gameObject, MagicColor.None);
// }
// }
public void SetColor(GameObject p)
{
if (operater == null)
{
operater = FindObjectOfType <MyMagicCube> ();
}
MagicColor curcolor = operater.Color;
// print (operater.EditColorStore [curcolor]);
if (curcolor != MagicColor.None && operater.EditColorStore [curcolor] > 7)
{
//print ("此颜色已经编辑完成" + curcolor + operater.EditColorStore [curcolor]);
return;
}
if (cubecolor.ContainsKey(p) && cubecolor [p] == curcolor)
{
//print ("颜色相同");
return;
}
bool cansetcolor = true;
if (editcolorfinished)
{
operater.ColorMapDelete(this);
}
MagicColor orignalcolor = MagicColor.None;
// 如果字典里面有当前的物体，则为替换颜色，如果没有，则为添加颜色
if (cubecolor.ContainsKey(p))
{
orignalcolor = cubecolor [p];
// 这些只是为了防止同一个块上出现两个相同的颜色和对面的颜色
foreach (GameObject g in cubecolor.Keys)
{
if (g != p)
{
if (!cubecolor [g].Equals(MagicColor.None))
{
if (cubecolor [g] == curcolor)
{
cansetcolor = false;
//print ("此块已经有相同颜色，请勿重复编辑");
break;
}
int index = (int)curcolor;
if (index >= 3 && (int)cubecolor [g] == index - 3)
{
cansetcolor = false;
//print ("颜色不匹配");
break;
}
else if (index < 3 && (int)cubecolor [g] == index + 3)
{
cansetcolor = false;
//print ("颜色不匹配");
break;
}
}
}
}
}
else
{
cubecolor.Add(p, curcolor);
//print ("添加新颜色");
}
// 这里先假设将颜色附上去，如果不合适再去掉
if (cansetcolor)
{
cubecolor [p] = curcolor;
}
else
{
return;
}
// TODO: 判断是否完成当前cube的颜色设定，如果完成则保存到字典中，如果没有则等待完成
if ((cubestyle == CubeStyle.Edge && cubecolor.Count == 2) || (cubestyle == CubeStyle.Corner && cubecolor.Count == 3))
{
editcolorfinished = true;
}
else
{
editcolorfinished = false;
}
if (editcolorfinished)
{
// foreach (GameObject g in cubecolor.Keys) {
// editcolorfinished = true;
// if (g.GetComponent <CubeFace> ().mycolor == MagicColor.None) {
// editcolorfinished = false;
// }
// }
if (cubecolor.ContainsValue(MagicColor.None))
{
editcolorfinished = false;
}
}
if (editcolorfinished)
{
//print ("当前块的颜色已经设置完成");
// TODO: 根据设定的颜色来标识当前cube，判断是否有重复
CubeMark mark = GetCubeMark();
if (operater.EditColorMap.ContainsValue(mark) && mark != CubeMark.None)
{
// print ("已经有这样的颜色块啦，请不要编辑错误了哦" + mark);
cubecolor [p] = orignalcolor;
}
else
{
// print ("颜色编辑成功" + mark);
operater.ColorDelete(orignalcolor);
operater.ColorAdd();
operater.ColorMapAdd(this, mark);
p.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [curcolor];
}
}
else
{
// print ("当前块的颜色尚未设置完成");
operater.ColorDelete(orignalcolor);
operater.ColorAdd();
p.GetComponent <MeshRenderer> ().material.color = MyMapPrefab.ColorMap [curcolor];
}
}
