public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Colored colored = ((Colored)attribute);
GUI.color = colored.color;
EditorGUI.PropertyField(position, property, true);
GUI.color = Color.white;
}
private void OnTriggerExit(Collider other)
{
Colored corScript = other.gameObject.GetComponent <Colored>();
if (corScript != null)
{
gameObject.GetComponentInParent <ChangeColor>().OnCollisionExitCor(corScript);
}
}
/*
* Adiciona uma cor, remaneja os aneis para que possa caber mais um
*/
public void ganhaCor(List <Colored.Corenum> coresDisponiveis)
{
/*
* Os aneis (ativos) tem o mesmo tamanho. Mas comecam em lugares diferente,
* e para isso rotacionamos eles.
* Tambem temos de fazer cada anel preenchero suficiente para ocupar sua porcao do circulo
*
* Eu estou pintando os aneis conforme o camaleao ganha cores.
* As cores que estao representadas na gameScene sao meramente ilustrativas.
*
* Isso da um pouco mais de flexibilidade.
* No momento o que determina as cores realmente, e a funcao GetColor que esta em Colored
*
*
*/
float rotacaoArco = 360 / coresDisponiveis.Count;
double tamArco = 1.0 / coresDisponiveis.Count;
float rotacao = 0;
//print("oba nova cor");
for (int i = 0; i < _rings.Length; i++)
{
Image r = _rings[i];
Image rImage = null;
foreach (Transform t in r.transform)
{
rImage = t.GetComponent <Image>();
}
//print("coresDisponiveis agora sao " + coresDisponiveis.Count);
if (i < coresDisponiveis.Count)
{
//print(rImage.name);
rImage.color = Colored.GetColor(coresDisponiveis[i]);
//print("vou pintar o anel de nome " + rImage.name + "com cor " + rImage.color.ToString());
}
else
{
//print("deixei o anel de id " + i + " transparente");
rImage.color = new Color(0, 0, 0, 0);
}
//print(r.name + " vai ter uma rotacao " + rotacao + " e vai preencher " + tamArco);
//Euler angles sao graus de 0 ate 360
//é para usar euler angles e nao rotation
//rotation é um formato interno do unity e nao é muito facil de usar
r.rectTransform.localEulerAngles = new Vector3(0, 0, rotacao);
r.fillAmount = (float)tamArco;
rotacao += rotacaoArco;
}
}
public override void Awake()
{
colored = GetComponent<Colored>();
renderer = GetComponent<Renderer>();
item = GetComponent<Item>();
if (!Extensions.Editor()) {
base.Awake();
item.onPick += keyColor.Recalculate;
item.onLose += keyColor.Recalculate;
}
}
public void TestCopyColored()
{
var colored = new Colored(System.Drawing.Color.FromArgb(255, 0, 0), new MathList(new Open("(")));
var clone = colored.Clone(false);
Assert.Equal(System.Drawing.Color.FromArgb(255, 0, 0), clone.Color);
CheckClone(colored, clone);
CheckClone(colored.InnerList, clone.InnerList);
var colorBox = new ColorBox(System.Drawing.Color.FromArgb(128, 0, 0), new MathList(new Close(")")));
var cloneBox = colorBox.Clone(false);
Assert.Equal(System.Drawing.Color.FromArgb(128, 0, 0), cloneBox.Color);
CheckClone(colorBox, cloneBox);
CheckClone(colorBox.InnerList, cloneBox.InnerList);
}
public void Write(
Colored <MessageTemplate> messageTemplate,
IReadOnlyList <Colored <object> > args,
IColoredTextWriter textWriter,
IFormatProvider formatProvider = null)
{
if (messageTemplate == null)
{
throw new ArgumentNullException(nameof(messageTemplate));
}
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (textWriter == null)
{
throw new ArgumentNullException(nameof(textWriter));
}
var formatter = GetFormatter(formatProvider);
var textForegroud = messageTemplate.Foreground;
var textBackground = messageTemplate.Background;
foreach (var token in messageTemplate.Value.Tokens)
{
switch (token)
{
case MessageTemplate.TextToken text:
textWriter.Write(textForegroud, textBackground, text.Text);
break;
case MessageTemplate.ArgumentToken arg:
var coloredValue = args[arg.Index];
string formatedValue = _valueFormatter.Format(coloredValue.Value, arg.Format, formatProvider, formatter);
WriteValueWithPadding(
textWriter, arg, formatedValue,
textForegroud, textBackground,
coloredValue.Foreground, coloredValue.Background);
break;
default:
throw new FormatException($"Unknown format token `{token?.GetType().Name}`.");
}
}
}
private void WriteColored(Colored colored)
{
var foreground = "";
var background = "";
if (colored.Background != Color.Transparent)
{
background = "background-color: " + HexColor(colored.Background) + ";";
}
if (colored.Foreground != Color.Transparent)
{
foreground = "color: " + HexColor(colored.Foreground) + ";";
}
Writer.Write("<span style=\"{0} {1}\">", foreground, background);
WriteTextElements(colored);
Writer.Write("</span>");
}
private void OnTriggerEnter(Collider other)
{
Colored colScript = other.gameObject.GetComponent <Colored>();
ChangeColor changeColorScript = GetComponentInParent <ChangeColor>();
if (colScript != null)
{
if (colScript.ganhaCor)
{
changeColorScript.AddColor(colScript.cores);
// colScript.gameObject.SetActive(false);
}
else
{
changeColorScript.OnCollisionEnterCor(colScript);
}
}
}
public void OnCollisionExitCor(Colored col)
{
//print("soltei de alguem colorido " + col.gameObject.name);
_coloredEmContato.Remove(col);
//verificar se estou encostado em alguem colorido
// se estou muda para a cor
// se nao estou volto para a cor default
//Se nao estava camuflado, entao nao passo a ficar
if (IsCamuflado())
{
SetCamufla(true);
}
//preciso de uma forma de verificar todos os itens em colisao comigo e todos que sao colored
// encontrei uma forma de fazer o segundo mas nao o primeiro. Para fazer manualmente:
// posso inserir numa lista todos os itens coloridos e retira-los quando collision exit
// dai e so checar essa lista
}
/*
* Troca a cor central para a cor desejada
* Destaca o anel correspondente
* Retorna os outros aneis para suas formas normais
*
*
* Note que no unity é necessário usar um for para capturar o primeiro elemento filho, mesmo que ele seja o unico
* Bem, isso é uma merda.
*/
public void setCentralColor(Colored.Corenum cor)
{
_centralColor.color = Colored.GetColor(cor);
Image rImage = null;
foreach (Image r in _rings)
{
foreach (Transform t in r.transform)
{
rImage = t.GetComponent <Image>();
}
if (rImage.color == Colored.GetColor(cor))
{
r.sprite = anelSelecionado;
}
else
{
r.sprite = anel;
}
}
}
void Awake()
{
Child = null;
colored = GetComponent<Colored>();
Hearts = 0;
}
/*
* Troca a cor central para a cor desejada
* Destaca o anel correspondente
* Retorna os outros aneis para suas formas normais
*
*
* Note que no unity é necessário usar um for para capturar o primeiro elemento filho, mesmo que ele seja o unico
* Bem, isso é uma merda.
*/
public void setCentralColor(Colored.Corenum cor)
{
_centralRock.color = Colored.GetColor(cor);
_selectedRock = _rocks[(int)cor];
}
void Awake()
{
Colored = GetComponent<Colored>();
}
private static void test01(int n, double q_d, double alpha, int seed_init)
//****************************************************************************80
//
// Purpose:
//
// TEST01 calls F_ALPHA with particular parameters.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 June 2010
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int N, the number of elements of the sequence to generate.
//
// Input, double Q_D, the variance of the sequence.
//
// Input, double ALPHA, the exponent of the power law.
//
// Input, int SEED_INIT, the initial seed for the random number generator.
//
{
int i;
List <string> output_unit = new();
typeMethods.r8NormalData data = new();
string output_filename = "alpha_" + alpha.ToString("0000.##") + ".txt";
//
// Report parameters.
//
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Generating " + n + " sample points.");
Console.WriteLine(" 1/F^ALPHA noise has ALPHA = " + alpha + "");
Console.WriteLine(" Variance is " + q_d + "");
Console.WriteLine(" Initial random number seed = " + seed_init + "");
int seed = seed_init;
double[] x = Colored.f_alpha(n, q_d, alpha, ref data, ref seed);
//
// Print no more than 10 entries of the data.
//
typeMethods.r8vec_print_part(n, x, 10, " Noise sample:");
//
// Write the data to a file.
//
for (i = 0; i < n; i++)
{
output_unit.Add(x[i].ToString(CultureInfo.InvariantCulture));
}
File.WriteAllLines(output_filename, output_unit);
Console.WriteLine(" Data written to file \"" + output_filename + "\"");
}
public void OnCollisionEnterCor(Colored col)
{
//print("encostei em alguem colorido " + col.gameObject.name + " com cor " + col.cor.name);
_coloredEmContato.Add(col);
}
void Awake()
{
colored = GetComponent <Colored>();
}
