public Entity AddColor(UnityEngine.Color newColor)
{
var component = new ColorComponent();
component.color = newColor;
return(AddColor(component));
}
public void StepOn(ColorComponent.pColor otherColor)
{
//Switch color with the colliding player's color
ColorComponent.pColor t_color = color.currentColor;
color.currentColor = otherColor;
//player.GetComponentInChildren<ColorComponent>().currentColor = t_color
}
public void ClearColor()
{
if (CanChangeColor())
{
ColorComponent.ClearColor();
}
}
private void CMax()
{
if (red > green)
{
if (red < blue)
{
maxval = blue;
maxComponent = ColorComponent.Blue;
}
else
{
maxval = red;
maxComponent = ColorComponent.Red;
}
}
else
{
if (green < blue)
{
maxval = blue;
maxComponent = ColorComponent.Blue;
}
else
{
maxval = green;
maxComponent = ColorComponent.Green;
}
}
}
public void SetColor()
{
if (CanChangeColor())
{
ColorComponent.SetColor();
}
}
static nfloat ValueForComponent(ColorComponent component, NSColor color)
{
nfloat val = 0;
switch (component)
{
case ColorComponent.Red:
val = color.RedComponent;
break;
case ColorComponent.Green:
val = color.GreenComponent;
break;
case ColorComponent.Blue:
val = color.BlueComponent;
break;
case ColorComponent.Brightness:
val = color.BrightnessComponent;
break;
case ColorComponent.Hue:
val = color.HueComponent;
break;
}
return(val);
}
public void SetColor(SweetsColorType colorType)
{
if (CanChangeColor())
{
ColorComponent.SetColor(colorType);
}
}
public CompositeGameObjectFromFile Build(Stream stream, IFileParserPlugin parser)
{
parser.Parse(stream, this);
var colors = new Queue <Vector4>();
colors.Enqueue(V4Colors.Red);
colors.Enqueue(V4Colors.Blue);
colors.Enqueue(V4Colors.Green);
colors.Enqueue(V4Colors.Yellow);
foreach (var com in components)
{
var tag = new ElementTag("Obj_" + Guid.NewGuid());//DateTime.Now.Ticks
var entity = manager.CreateEntity(tag);
var cc = new List <IGraphicComponent>();
cc.Add(com);
cc.Add(EntityBuilders.GetObjGroupsRender());
cc.Add(EntityBuilders.GetTransformation());
//var material = new PositionColorsComponent();
//material.Colors = new Vector4[com.Positions.Length];
//for (var i =0;i < com.Positions.Length; ++i) {
// material.Colors[i] = V4Colors.Red;
//}
cc.Add(ColorComponent.CreateDiffuse(V4Colors.Red));
cc.Add(new ManipulatableComponent());
entity.AddComponents(cc);
entity.AddComponents(others);
gobj.AddEntity(tag);
}
return(gobj); //new SingleGameObject(tag, info.File.Name);
}
public static Color GetColor(this ColorComponent colorComponent)
{
return((typeof(ColorComponent)
.GetRuntimeField(colorComponent.ToString())
.GetCustomAttributes(typeof(ColorAttribute), false)
.First() as ColorAttribute).Color);
}
public static VisualPolylineObject Create(IContextState context, ElementTag tag,
Vector3[] points, Vector4 color, bool isVisible = true)
{
var manager = context.GetEntityManager();
var indeces = new List <int>();
var pos = new List <Vector3>();
var prev = points[0];
for (var i = 0; i < points.Length; i++)
{
pos.Add(prev);
pos.Add(points[i]);
prev = points[i];
}
for (var i = 0; i < pos.Count; i++)
{
indeces.AddRange(new[] { i, i });
}
var geo = context.GetGeometryPool().AddGeometry(new ImmutableGeometryData(pos, indeces));
manager
.CreateEntity(tag)
.AddComponent(geo)
.AddComponent(TransformComponent.Identity())
.AddComponent(ColorComponent.CreateDiffuse(color))
.AddComponent(isVisible ? RenderableComponent.AsLineList() : RenderableComponent.AsLineList().Disable());
return(new VisualPolylineObject(tag));
}
public CircleState(ColorComponent color, PositionComponent pos, SizeComponent size, SpeedComponent speed)
{
colorComponent = color;
positionComponent = pos;
sizeComponent = size;
speedComponent = speed;
}
static void DrawToImageComponent(ICanvas img, IDensityMatrix matrix, ColorComponent comp)
{
Logger.PrintInfo("matrix = [" + matrix.Width + "x" + matrix.Height + " " + matrix.Maximum + "]");
IColorMap cm = new GrayColorMap();
Logger.PrintInfo("drawing component '" + comp + "'");
PaintImageData(matrix, cm, img, comp);
}
public SourceNodeView(Enum componentType) : base(componentType)
{
ColorComponent = (ColorComponent)componentType;
var color = ((ColorComponent)componentType).GetColor();
NodeNameLabel.TextColor = color.ToNSColor();
}
static void Main()
{
Font _font = new Font("fonts/JetBrainsMono-Regular.ttf");
var es = new EntityManager();
const uint windowWidth = 1024;
const uint windowHeight = 768;
const int numEntities = 85000;
es.CreateEntities(numEntities);
var bounds = new FloatRect(.0f, .0f, windowWidth, windowHeight);
var window = new RenderWindow(new VideoMode(windowWidth, windowHeight), $"ECS Moving {numEntities} Circles");
window.Closed += (sender, e) => { ((Window)sender).Close(); };
var entities = es.GetEntities();
var cc = new ColorComponent(entities.Count);
var pc = new PositionComponent(entities.Count, ref bounds);
var rc = new RadiusComponent(entities.Count);
var vc = new VelocityComponent(entities.Count);
Text text = new Text("", _font, 24);
text.FillColor = Color.Yellow;
foreach (Entity entity in entities)
{
cc.AddComponent(entity);
pc.AddComponent(entity);
rc.AddComponent(entity);
vc.AddComponent(entity);
}
var ms = new MoveSystem(ref bounds);
Vertex[] vertexes = new Vertex[numEntities * 4];
for (int i = 0; i < numEntities * 4; i++)
{
vertexes[i] = new Vertex();
}
var ds = new DrawSystem(ref vertexes);
var clock = new Clock();
RenderStates _renderStates = new RenderStates(TextureManager.Instance.CircleTexture);
var cycle = 0;
int frames = 0;
while (window.IsOpen)
{
var dt = clock.Restart();
window.Clear();
foreach (Entity entity in entities)
{
ref Vector2f position = ref pc.GetComponent(entity);
ref var velocity = ref vc.GetComponent(entity);
ref var color = ref cc.GetComponent(entity);
public static Color ToColor(this ColorComponent Value, ColorComponent Component)
{
ColorComponent finalValue;
switch (Component)
{
case ColorComponent.Ink:
finalValue = Value;
break;
case ColorComponent.Paper:
finalValue = (ColorComponent)((byte)(Value & ColorComponent.Paper) >> 3) | (Value & ColorComponent.Bright);
break;
default:
return(Color.Transparent);
}
switch (finalValue & ColorComponent.Ink)
{
case ColorComponent.InkBlack:
return(Color.Black);
case ColorComponent.InkBlue:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(0, 0, 255) : Color.FromArgb(0, 0, 192));
case ColorComponent.InkRed:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(255, 0, 0) : Color.FromArgb(192, 0, 0));
case ColorComponent.InkFuchsia:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(255, 0, 255) : Color.FromArgb(192, 0, 192));
case ColorComponent.InkGreen:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(0, 255, 0) : Color.FromArgb(0, 192, 0));
case ColorComponent.InkCyan:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(0, 255, 255) : Color.FromArgb(0, 192, 192));
case ColorComponent.InkYellow:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(255, 255, 0) : Color.FromArgb(192, 192, 0));
case ColorComponent.InkWhite:
return(Value.HasFlag(ColorComponent.Bright) ? Color.FromArgb(255, 255, 255) : Color.FromArgb(192, 192, 192));
}
return(Color.Transparent);
}
public static void TeleporterOff(ColorComponent.pColor color)
{
if(color == ColorComponent.pColor.red) {
redTeleportOn = false;
} else if(color == ColorComponent.pColor.blue) {
blueTeleportOn = false;
}
// print (color.ToString () + " off!");
}
private void Start()
{
animator = GetComponent<Animator>();
color = GetComponent<ColorComponent>();
if(target == null)
Debug.Log("Hook up target", this);
myAudioSource = GetComponent<AudioSource>();
}
private Byte GetChannelFromValue(UInt32 readValue, ColorComponent type)
{
UInt32 val = (UInt32)(readValue & limitMasks[(Int32)type]);
val = (UInt32)(val >> this.shiftAmounts[(Int32)type]);
Double valD = (Double)(val * multipliers[(Int32)type]);
return((Byte)Math.Min(255, Math.Round(valD, MidpointRounding.AwayFromZero)));
}
private void Start()
{
animator = GetComponent <Animator>();
color = GetComponent <ColorComponent>();
if (target == null)
{
Debug.Log("Hook up target", this);
}
myAudioSource = GetComponent <AudioSource>();
}
public void Init(int _x, int _y, GridManager _grid, GridManager.PieceType _type)
{
data.x = _x;
data.y = _y;
GridRef = _grid;
Type = _type;
if (Type != GridManager.PieceType.EMPTY)
{
ColorComponent.SetColor((ColorPiece.ColorType)Random.Range(0, ColorComponent.NumColors));
}
}
public static LightGameObject CreateDirectionLight(IEntityManager manager, Vector3 direction) // ,
{
var tag = new ElementTag("DirectionLight_" + Interlocked.Increment(ref lights));
manager.CreateEntity(tag)
.AddComponents(
LightComponent.CreateDirectional(0.2f, 2, direction),
ColorComponent.CreateDiffuse(new Vector4(1, 1, 1, 1))
);
return(new LightGameObject(tag, "DirectionLight"));
}
public static LightGameObject CreateAmbientLight(IEntityManager manager)
{
var tag = new ElementTag("AmbientLight_" + Interlocked.Increment(ref lights));
manager.CreateEntity(tag)
.AddComponents(
LightComponent.CreateAmbient(0.4f, 0),
ColorComponent.CreateDiffuse(V4Colors.White)
);
return(new LightGameObject(tag, "AmbientLight"));
}
public static LightGameObject CreatePointLight(IEntityManager manager, Vector3 position) //
{
var tag = new ElementTag("PointLight_" + Interlocked.Increment(ref lights));
manager.CreateEntity(tag)
.AddComponents(
LightComponent.CreatePoint(0.4f, 1, position),
ColorComponent.CreateDiffuse(new Vector4(1, 1, 1, 1))
);
return(new LightGameObject(tag, "PointLight"));
}
//renders all objects and menus. Should seperate into different methods depending on what is being drawn.
public void Render(List <Entity> entsToDraw, List <Entity> UIEntsToDraw, RenderWindow app)
{
//draw game objects.
foreach (Entity ent in entsToDraw)
{
PhysicalProps physComponent = ent.componentsList.OfType <PhysicalProps>().First();
ColorComponent colourComponent = ent.componentsList.OfType <ColorComponent>().First();
RectangleShape shape = new RectangleShape();
shape.FillColor = colourComponent.objectColor;
shape.Position = new SFML.System.Vector2f(physComponent.x - (physComponent.sizeX / 2), physComponent.y - (physComponent.sizeY / 2));
shape.Size = new SFML.System.Vector2f(physComponent.sizeX, physComponent.sizeY);
app.Draw(shape);
}
//Pause Code.
if (Game.getPauseState())
{
RectangleShape pauseShade = new RectangleShape();
pauseShade.FillColor = new Color(0, 0, 0, 128);
pauseShade.Position = new SFML.System.Vector2f(0, 0);
pauseShade.Size = new SFML.System.Vector2f(app.Size.X, app.Size.Y);
app.Draw(pauseShade);
}
if (UIEntsToDraw.Any())
{
//draw UI elements last.
foreach (Entity ent in UIEntsToDraw)
{
if (ent.componentsList.OfType <UIImage>().Any())
{
PhysicalProps physComponent = ent.componentsList.OfType <PhysicalProps>().First();
UIImage UIComponent = ent.componentsList.OfType <UIImage>().First();
ent.sprite.Texture = UIComponent.texture;
ent.sprite.Color = UIComponent.col;
app.Draw(ent.sprite);
}
else if (ent.componentsList.OfType <UIText>().Any())
{
}
}
}
}
public Entity ReplaceColor(UnityEngine.Color newColor)
{
ColorComponent component;
if (hasColor) {
WillRemoveComponent(ComponentIds.Color);
component = color;
} else {
component = new ColorComponent();
}
component.color = newColor;
return ReplaceComponent(ComponentIds.Color, component);
}
private void brightButton_Click(object sender, EventArgs e)
{
if (brightButton.Checked)
{
currentBright = ColorComponent.Bright;
}
else
{
currentBright = ColorComponent.None;
}
UpdateDragColorsImage();
}
private void flashButton_Click(object sender, EventArgs e)
{
if (flashButton.Checked)
{
currentFlash = ColorComponent.Flash;
}
else
{
currentFlash = ColorComponent.None;
}
UpdateDragColorsImage();
}
public void ChangeColor(ColorComponent.pColor color)
{
Renderer[] renderers = GetComponentsInChildren<Renderer> ();
foreach(Renderer rend in renderers) {
if (color == ColorComponent.pColor.blue) {
rend.material.color = new Color(54f/255f, 64f/255f, 244f/255f);
} else if(color == ColorComponent.pColor.red) {
rend.material.color = new Color(201f/255f, 65f/255f, 65f/255f);
} else if(color == ColorComponent.pColor.grey) {
Debug.Log("No gray teleporters", this);
}
}
}
//public MagickColor ToMagickColor()
//{
// //var m = new MagickColor();
// //m.r
//}
public double GetComponent(ColorComponent comp)
{
switch (comp)
{
case ColorComponent.A: return(A);
case ColorComponent.R: return(R);
case ColorComponent.G: return(G);
case ColorComponent.B: return(B);
}
return(0.0);
}
public SettingsScript(ISettingsManager <Settings> settings, Action <ISettingsManager <Settings> > set,
Func <ISettingsManager <Settings>, bool> active, IEntity entity)
{
_settings = settings;
_set = set;
_active = active;
_color = entity.GetComponent <ColorComponent>();
var position = entity.GetComponent <PositionComponent>();
var size = entity.GetComponent <SizeComponent>();
_min = new Vector2(position.Position.X - size.Width / 2f, position.Position.Y - size.Height / 2f);
_max = new Vector2(position.Position.X + size.Width / 2f, position.Position.Y + size.Height / 2f);
}
private float lastSpacePressTime = 0f;//on ne peut pas appuyer sur espace pendant les deux premières secondes
public void UpdateSystem()
{
if (Input.GetKeyDown(KeyCode.Space))
{
if (Time.time - lastSpacePressTime < 2f)
{
string timeRemaining = (2f - (Time.time - lastSpacePressTime)).ToString();
Debug.Log("Wait until the cooldown is over; time remaining in seconds : " + timeRemaining);
}
else
{
lastSpacePressTime = Time.time;
Debug.Log("Space button pressed; activating 2 seconds cooldown");
for (int i = 0; i < world.PastPositionsComponents.Count; i++)
{
PositionComponent posC = new PositionComponent();
ColorComponent colorC = new ColorComponent();
SizeComponent sizeC = new SizeComponent();
SpeedComponent speedC = new SpeedComponent();
posC.id = world.PositionComponents[i].id;
colorC.id = world.ColorComponents[i].id;
sizeC.id = world.SizeComponents[i].id;
speedC.id = world.SpeedComponents[i].id;
posC.pos = world.PastPositionsComponents[i].pos.Dequeue();
world.PositionComponents[i] = posC;
world.PastPositionsComponents[i].timestamps.Dequeue();
manager.UpdateShapePosition(world.PositionComponents[i].id, world.PositionComponents[i].pos);
colorC.color = world.PastColorsComponents[i].colors.Dequeue();
world.ColorComponents[i] = colorC;
world.PastColorsComponents[i].timestamps.Dequeue();
manager.UpdateShapeColor(world.ColorComponents[i].id, world.ColorComponents[i].color);
sizeC.size = world.PastSizesComponents[i].sizes.Dequeue();
world.SizeComponents[i] = sizeC;
world.PastSizesComponents[i].timestamps.Dequeue();
manager.UpdateShapeSize(world.SizeComponents[i].id, world.SizeComponents[i].size);
speedC.speed = world.PastSpeedsComponents[i].speeds.Dequeue();
world.SpeedComponents[i] = speedC;
world.PastSpeedsComponents[i].timestamps.Dequeue();
}
}
}
}
public static void TeleporterOn(ColorComponent.pColor color)
{
if(color == ColorComponent.pColor.red) {
redTeleportOn = true;
} else if(color == ColorComponent.pColor.blue) {
blueTeleportOn = true;
}
if(redTeleportOn && blueTeleportOn) {
NextLevel();
redTeleportOn = false;
blueTeleportOn = false;
}
// print (color.ToString () + " on!");
}
public Entity ReplaceColor(UnityEngine.Color newColor)
{
ColorComponent component;
if (hasColor)
{
WillRemoveComponent(ComponentIds.Color);
component = color;
}
else
{
component = new ColorComponent();
}
component.color = newColor;
return(ReplaceComponent(ComponentIds.Color, component));
}
public static LightObject CreatePointLight(IEntityManager manager, Vector3 position) //
{
var index = 1;
if (!occupiedIndex.Add(index))
{
throw new LightIndexOccupiedException(index);
}
var tag = new ElementTag("PointLight_" + Interlocked.Increment(ref lights));
manager.CreateEntity(tag)
.AddComponent(LightComponent.CreatePoint(0.4f, index, position))
.AddComponent(ColorComponent.CreateDiffuse(new Vector4(1, 1, 1, 1)));
return(new LightObject(tag, "PointLight"));
}
public static double GetNormalizedValue(ColorComponent component, int red, int green, int blue)
{
switch (component)
{
case ColorComponent.Red:
return((double)red / (red + green + blue));
case ColorComponent.Green:
return((double)green / (red + green + blue));
case ColorComponent.Blue:
return((double)blue / (red + green + blue));
default:
throw new NotImplementedException();
}
}
public void SetPixelComponent(int x, int y, ColorComponent comp, double colorVal)
{
var rgba = Pixels.GetArea(x, y, 1, 1);
byte bVal = (byte)(ColorHelpers.Clamp(colorVal) * 255.0);
switch (comp)
{
case ColorComponent.A: rgba[3] = bVal; break;
case ColorComponent.R: rgba[0] = bVal; break;
case ColorComponent.G: rgba[1] = bVal; break;
case ColorComponent.B: rgba[2] = bVal; break;
}
Pixels.SetArea(x, y, 1, 1, rgba);
}
public void CoreDestroyed(ColorComponent coreColor)
{
switch (coreColor.MyColor)
{
case PatternColor.RED:
Red--;
if (Red == 0)
{
ChangeColor(RedRenderers, PatternColor.WHITE);
}
break;
case PatternColor.GREEN:
Green--;
if (Green == 0)
{
ChangeColor(GreenRenderers, PatternColor.WHITE);
}
break;
case PatternColor.BLUE:
Blue--;
if (Blue == 0)
{
ChangeColor(BlueRenderers, PatternColor.WHITE);
}
break;
case PatternColor.YELLOW:
Yellow--;
if (Yellow == 0)
{
ChangeColor(YellowRenderers, PatternColor.WHITE);
}
break;
}
NGUITools.PlaySound(HitSound);
if (Red == 0 && Green == 0 && Blue == 0 && Yellow == 0)
{
KillBoss();
}
else
{
animController.SetTrigger("hit");
}
}
public void ChangeColor(ColorComponent.pColor color)
{
Color mainColor = Color.white;
Color emitColor = Color.white;
if (color == ColorComponent.pColor.blue) {
mainColor = new Color(54f/255f, 64f/255f, 244f/255f);
emitColor = Color.blue;
} else if(color == ColorComponent.pColor.red) {
mainColor = new Color(201f/255f, 65f/255f, 65f/255f);
emitColor = Color.red;
} else if(color == ColorComponent.pColor.grey) {
mainColor = Color.white;
emitColor = Color.grey;
}
transform.FindChild ("button_main").renderer.material.color = mainColor;
transform.FindChild ("buttonBase").renderer.material.SetColor("_EmitColor", emitColor);
}
public void SteppedOn(ColorComponent.pColor color)
{
switch(type)
{
case Type.BUTTON:
ColorComponent.pColor buttonColor = gameObject.GetComponent<GameButton>().GetColor();
if( buttonColor == color || buttonColor == ColorComponent.pColor.grey )
gameObject.GetComponent<GameButton>().StepOn();
break;
case Type.TELEPORTER:
ColorComponent.pColor teleporterColor = gameObject.GetComponent<Teleporter>().GetColor();
if(teleporterColor == color)
gameObject.GetComponent<Teleporter>().StepOn();
break;
case Type.NONE:
break;
default:
break;
}
}
public void PlayerEnter(ColorComponent.pColor color)
{
if( tileObject != null )
tileObject.SteppedOn(color);
}
private static void MapPixel(Dictionary<int, PixelMap[]> pixelMapping, int universe, ColorComponent colorComponent, int x, int y, ref int mappingPos)
{
PixelMap[] mapping;
if (!pixelMapping.TryGetValue(universe, out mapping))
{
mapping = new PixelMap[512];
pixelMapping.Add(universe, mapping);
}
mapping[mappingPos++] = new PixelMap
{
X = x,
Y = y,
ColorComponent = colorComponent
};
}
// Use this for initialization
void Start()
{
color = gameObject.GetComponent<ColorComponent> ();
color.currentColor = ColorComponent.pColor.grey;
}
public Tile MoveObjectToTile( Tile tile, Direction direction, ColorComponent.pColor color )
{
int index = GetIndex(tile);
int targetIndex = 0;
switch(direction)
{
case Direction.UP:
targetIndex = index - width;
if(targetIndex > -1)
{
if(!tiles[targetIndex].IsReserved() || tiles[targetIndex].canBeBridged)
{
tiles[targetIndex].ReserveNode(true, true);
// tiles[targetIndex].PlayerEnter(color);
return tiles[targetIndex];
}
}
break;
case Direction.DOWN:
targetIndex = index + width;
if(targetIndex < (width * height) )
{
if(!tiles[targetIndex].IsReserved() || tiles[targetIndex].canBeBridged)
{
tiles[targetIndex].ReserveNode(true, true);
// tiles[targetIndex].PlayerEnter(color);
return tiles[targetIndex];
}
}
break;
case Direction.LEFT:
targetIndex = (index % width) - 1;
if(targetIndex > -1)
{
if(!tiles[index - 1].IsReserved() || tiles[index - 1].canBeBridged)
{
tiles[index - 1].ReserveNode(true, true);
// tiles[index - 1].PlayerEnter(color);
return tiles[index - 1];
}
}
break;
case Direction.RIGHT:
targetIndex = (index % width) + 1;
if(targetIndex < width)
{
if(!tiles[index + 1].IsReserved() || tiles[index + 1].canBeBridged)
{
tiles[index + 1].ReserveNode(true, true);
// tiles[index + 1].PlayerEnter(color);
return tiles[index + 1];
}
}
break;
default:
return null;
}
return null;
}
public Entity AddColor(UnityEngine.Color newColor)
{
var component = new ColorComponent();
component.color = newColor;
return AddColor(component);
}
public Entity AddColor(ColorComponent component)
{
return AddComponent(ComponentIds.Color, component);
}
void Awake()
{
m_color = GetComponent<ColorComponent>();
}
private void Start()
{
color = GetComponent<ColorComponent>();
forceField = transform.parent.FindChild ("Force Field").GetComponent<ForceField> ();
myAudioSource = GetComponent<AudioSource>();
}
