public virtual void LoadContent(GraphicsDevice graphicsDevice,
ContentManager contentManager, ScreenDescription screenDescription)
{
ExecutionState = InnerExecutionState.INIT;
var width = (int)screenDescription.ScreenSizeInformation.WidhtInnerScreen;
var height = (int)screenDescription.ScreenSizeInformation.HeightInnerScreen;
_spriteBatch = new SpriteBatch(graphicsDevice);
List <GameObject> gameObjects = new List <GameObject>();
foreach (GameObjectDescription description in screenDescription.Items)
{
var texture = contentManager.Load <Texture2D>(description.AssetName);
var obj = GameObjectBuilder.Create()
.SetPosition(description.CurrentPosition.X, description.CurrentPosition.Y)
.SetOrientation(description.ObjectOrientation)
.SetAssetName(description.AssetName)
.SetSize((int)description.Width, (int)description.Height)
.SetObjectType(description.GameObjectType)
.Build(contentManager);
gameObjects.Add(obj);
}
var background = contentManager.Load <Texture2D>(screenDescription.AssetNameBackground);
_gameMediator = new GameMediator(screenDescription.ScreenSizeInformation);
_gameMediator.Set(gameObjects.ToArray());
_gameMediator.SetBackground(background);
// TODO remove after test
_gameMediator.Set(contentManager.Load <SpriteFont>("Labels/LabelLarge"));
}
GameObject CreateMonster(MonsterPrototype prototype, int spriteX, int spriteY, int posX, int posY)
{
Monster monsterComponent = new Monster(GlobalScripts, Map[posX, posY], prototype);
Player player = GlobalScripts.GetComponent <Player>();
GameObject monster = new GameObjectBuilder()
.AddComponent(new Transform(new Vector2(Map.Size * posX, Map.Size * posY)))
.AddComponent(new SpriteRenderer(Monsters))
.AddComponent(CreateAnimator(Monsters, spriteX, spriteY))
.AddComponent(CreateAnimationStateMachine(Map.Size))
.AddComponent(monsterComponent)
.AddComponent(new Dimentions(0, 0, Map.Size, Map.Size))
.AddComponent(new Hoverable(() => player.RequestInfoboxOverride(
"<" + monsterComponent.Species + ">" + Environment.NewLine +
"HP: " + monsterComponent.HitPoints.Remaining + " / " + monsterComponent.HitPoints.Max + Environment.NewLine +
"Speed: " + monsterComponent.Speed.Max + Environment.NewLine +
"Strength: " + monsterComponent.Strength + Environment.NewLine +
"Possible Types: " + string.Join(", ", monsterComponent.Species.EnemyAwareness),
monsterComponent), () => player.InvalidateInfoboxOverride(monsterComponent)))
.Register(this);
Map[posX, posY].OccupiedBy = monster;
if (Map[posX, posY].Room.View != Room.Visibility.Visible)
{
monster.GetComponent <SpriteRenderer>().Active = false;
}
GlobalScripts.GetComponent <TurnManager>().Monsters.Add(monsterComponent);
return(monster);
}
public IEnumerator DestroyAll()
{
var source = new GameObject().AddComponent <GameObjectPoolBehaviour>();
source.PoolDisable();
var builder = new GameObjectBuilder <GameObjectPoolBehaviour>(source);
var pool = new GameObjectPoolCollection <GameObjectPoolBehaviour>(builder);
Transform parent = new GameObject().transform;
for (int i = 0; i < 10; i++)
{
pool.Enable(parent);
}
Assert.AreEqual(10, pool.Count);
Assert.AreEqual(10, parent.childCount);
pool.DisableAll();
pool.DestroyAll();
yield return(null);
Assert.AreEqual(0, pool.Count);
Assert.AreEqual(0, parent.childCount);
}
public void OneTimeSetUp()
{
fakeLocalPlayer = GameObjectBuilder.New()
.WithRigidbody()
.WithLocalMovement()
.Build();
fakeLocalRigidbody = fakeLocalPlayer.GetComponent <Rigidbody>();
fakeGround = GameObjectBuilder.New()
.WithIsGround()
.Build();
}
private void createCard(Transform parent, string name, string descripton, string cardGroupName, Sprite front, Sprite back)
{
GameObjectBuilder builder = new GameObjectBuilder(name, parent);
Transform cardRoot = builder.GameObject.transform;
Card card = builder.GameObject.AddComponent<Card>();
card.description = descripton;
card.cardName = name;
card.cardGroupName = cardGroupName;
card.front = createCardTextureGame("Front", cardRoot, front);
card.back = createCardTextureGame("Back", cardRoot, back);
card.back.SetActive(false);
}
public static GameObject CreateInstance(GameObject gObject, Transform parent, string name = null, bool isPrefab = false)
{
GameObject intermediateParent = new GameObject();
intermediateParent.transform.parent = parent;
Transform srcParent = gObject.transform.parent;
if (null != srcParent)
{
intermediateParent.transform.localPosition = srcParent.localPosition;
intermediateParent.transform.localRotation = srcParent.localRotation;
intermediateParent.transform.localScale = srcParent.localScale;
}
string appliedName;
if (null == name)
{
string baseName = Utils.GetBaseName(gObject.name);
appliedName = Utils.CreateUniqueName(baseName);
}
else
{
appliedName = name;
}
intermediateParent.name = appliedName + Utils.blenderHiddenParent;
GameObject res;
GameObjectBuilder builder = gObject.GetComponent <GameObjectBuilder>();
if (builder)
{
res = builder.CreateInstance(gObject, intermediateParent.transform, isPrefab);
}
else
{
// duplicate object or subobject
res = GameObject.Instantiate(gObject, intermediateParent.transform);
}
res.name = appliedName;
// Name material too
MeshRenderer meshRenderer = res.GetComponentInChildren <MeshRenderer>(true);
if (null != meshRenderer)
{
meshRenderer.material.name = Utils.GetMaterialName(res);
// TODO: ALSO rename materials after the first one.
}
return(res);
}
// Conversion functions
public static Replay FromSnapshotList(List <Snapshot> snaps)
{
// Retrieve all objects
HashSet <GameObject> objects = new HashSet <GameObject>(ReferenceEqualityComparer.Default);
foreach (Snapshot s in snaps)
{
foreach (GameObject o in s.objects)
{
objects.Add(o);
}
}
GameObject[] objs = objects.ToArray();
Dictionary <GameObject, int> dictionary = new Dictionary <GameObject, int>(ReferenceEqualityComparer.Default);
for (int i = 0; i < objs.Length; i++)
{
dictionary.Add(objs[i], i);
}
// Convert them
GameObjectBuilder[] builders = new GameObjectBuilder[objs.Length];
for (int i = 0; i < objs.Length; i++)
{
builders[i] = new GameObjectBuilder();
//builders[i].type = objs[i].GetType();
builders[i].type_str = objs[i].GetType().AssemblyQualifiedName;
}
// Compute ssnapshots
List <SSnapshot> sss = new List <SSnapshot>();
foreach (Snapshot s in snaps)
{
SSnapshot ss = new SSnapshot();
ss.lvl = s.lvl;
ss.objects_states = s.objects_states;
ss.objects_ids = new List <int>();
foreach (GameObject o in s.objects)
{
ss.objects_ids.Add(dictionary[o]);
}
sss.Add(ss);
}
Replay rep = new Replay();
rep.objects = builders;
rep.snapshots = sss;
return(rep);
}
public PlayerShooter(int _ShootingSpeed, Transform _Gunpoint, Transform _Heropoint)
{
ProjectileSprite = Resources.Load <Sprite>("Projactile");
ShootingSpeed = _ShootingSpeed;
ProjactileBuilder = new GameObjectBuilder();
Gunpoint = _Gunpoint;
Heropoint = _Heropoint;
mass = 2F;
RightBullets = new List <GameObject>();
LeftBullets = new List <GameObject>();
IdleProjactile = ProjactileBuilder.Visual.Sprite(ProjectileSprite).Physics.BoxCollider2D().TransformPositionChange(Gunpoint.position).ScaleChanger(5, 5).ProjactileBehovour();
IdleProjactile.SetActive(false);
}
public void SetUp()
{
unityGameObjectProxyMock.Reset();
unityTimeProxyMock.Reset();
gameStateMock.Reset();
fakePlayerInstance = GameObjectBuilder.New()
.WithPositionAndRotation(Vector3.zero, Quaternion.identity)
.WithRigidbody()
.Build();
controller = new RemoteMovementController(unityGameObjectProxyMock.Object);
controller.SetState(gameStateMock.Object);
unityGameObjectProxyMock.Setup(x => x.Find(It.IsAny <string>())).Returns(fakePlayerInstance);
}
public ImportFileLoadedItem(MainWindowViewModel main, ImportFileInfo info) : base(main, null)
{
this.info = info;
reset = new ManualResetEventSlim(true);
tempFileName = Path.ChangeExtension(info.File.FullName, ".temp");
File.Delete(tempFileName);
//
var bl = new GameObjectBuilder(main.context.GetEntityManager());
compositeGameObject = bl.Build(info.File, info.Parser);
base.GameObj = compositeGameObject;
//
watcher = new FileSystemWatcher(info.File.DirectoryName, "*" + Path.GetExtension(info.File.Name));
watcher.EnableRaisingEvents = true;
watcher.Changed += OnFileChanged;
}
public void OnPlayerGone_RemoveRemotePlayerFromLocalGame()
{
// Given
var socketEvent = BuildSocketIOEventWithPlayer("test", "TEST_ID", 4.4F, 5.5F);
var fakeGameObject = GameObjectBuilder.New().Build();
unityGameObjectProxyMock.Setup(x => x.Find(It.IsAny <string>())).Returns(fakeGameObject);
// When
controller.OnPlayerGone(socketEvent);
// Then: remote player object removed from game
unityGameObjectProxyMock.Verify(x => x.Find("Player:TEST_ID"), Times.Once);
unityObjectProxyMock.Verify(x => x.DestroyImmediate(fakeGameObject), Times.Once);
// Then: player removed from the state
gameStateMock.Verify(x => x.RemoveRemotePlayer("TEST_ID"), Times.Once);
}
public void EnableWithPositionAndRotation()
{
var source = new GameObject().AddComponent <GameObjectPoolBehaviour>();
source.PoolDisable();
var builder = new GameObjectBuilder <GameObjectPoolBehaviour>(source);
var pool = new GameObjectPoolCollection <GameObjectPoolBehaviour>(builder);
GameObjectPoolBehaviour behaviour = pool.Enable(Vector3.one, Quaternion.Euler(Vector3.one));
behaviour.PoolEnable();
Assert.NotNull(behaviour);
Assert.True(behaviour.IsPoolEnabled());
Assert.AreEqual(Vector3.one, behaviour.transform.position);
Assert.True(QuaternionEqualityComparer.Instance.Equals(Quaternion.Euler(Vector3.one), behaviour.transform.rotation));
}
public void EnableWithParent()
{
var source = new GameObject().AddComponent <GameObjectPoolBehaviour>();
source.PoolDisable();
var builder = new GameObjectBuilder <GameObjectPoolBehaviour>(source);
var pool = new GameObjectPoolCollection <GameObjectPoolBehaviour>(builder);
Transform parent = new GameObject().transform;
GameObjectPoolBehaviour behaviour = pool.Enable(parent);
behaviour.PoolEnable();
Assert.NotNull(behaviour);
Assert.True(behaviour.IsPoolEnabled());
Assert.AreEqual(parent, behaviour.transform.parent);
}
public void SetUp()
{
unityDebugProxyMock.Reset();
unityObjectProxyMock.Reset();
unityGameObjectProxyMock.Reset();
gameStateMock.Reset();
instantiatorMock.Reset();
fakePlayerPrefab = GameObjectBuilder.New().Build();
controller = new PlayersManagementController(
unityGameObjectProxyMock.Object, unityObjectProxyMock.Object, unityDebugProxyMock.Object, instantiatorMock.Object);
controller.SetPlayerPrefab(fakePlayerPrefab);
controller.SetState(gameStateMock.Object);
socketMock = new Mock <ISocketIOComponent>();
controller.SetSocket(socketMock.Object);
socketMock.Setup(x => x.IsConnected).Returns(true);
instantiatorMock.Setup(x => x.InstantiatePrefab(It.IsAny <GameObject>(), It.IsAny <Vector3>(), It.IsAny <Quaternion>(), null)).Returns(fakeLocalPlayer);
}
void CreateMap()
{
MapBlueprint map = MapBlueprint.FromFile(@"..\..\..\..\..\map.bin");
GameObject[,] tiles = new GameObject[map.Encoding.GetLength(0), map.Encoding.GetLength(1)];
Dictionary <byte, Room> rooms = new Dictionary <byte, Room>();
for (int x = 0; x < map.Encoding.GetLength(0); x++)
{
for (int y = 0; y < map.Encoding.GetLength(1); y++)
{
byte roomID = map.Encoding[x, y][0];
byte doorID = map.Encoding[x, y][1];
if (!rooms.ContainsKey(roomID))
{
rooms.Add(roomID, new Room(roomID));
}
Room room = rooms[roomID];
MapNode node = new MapNode(x, y, doorID, room);
tiles[x, y] = new GameObjectBuilder()
.AddComponent(new Transform(new Vector2(x * Map.Size, y * Map.Size)))
.AddComponent(new SpriteRenderer(Wall, .9f))
.AddComponent(node)
.AddComponent(new Dimentions(0, 0, Map.Size, Map.Size))
.AddComponent(new Clickable(() => GlobalScripts.GetComponent <Player>().SelectNode(node)))
//.AddComponent(new Hoverable(() => GlobalScripts.GetComponent<Player>().RequestInfoboxOverride("Room ID: " + node.Room.ID, node)))
.Register(this);
}
}
Map = new Map(tiles, rooms.Values);
Map.SetupRooms(map.StartRoomId);
Map.SetNeighbors();
Map.SetTileGraphics(Floor, FloorDark, Wall);
GlobalScripts.GetComponent <MapPanner>().Map = Map;
}
private static IGameWorld CreateWorld(IConsoleWriter consoleWriter)
{
var gameObjectLocator = new GameObjectLocator();
var lineIntersectionResolver = new LianBarskyIntersectionResolver();
var geometryMathService = new GeometryMathService(lineIntersectionResolver);
var serializedGameObjectDataProvider = new SerializedGameObjectDataProvider();
var enemyData = serializedGameObjectDataProvider.GetEnemyData();
var playerData = serializedGameObjectDataProvider.GetPlayerData();
var stoneData = serializedGameObjectDataProvider.GetStoneData();
var shellData = serializedGameObjectDataProvider.GetShellData();
var shellInputComponent = new ShellInputComponent();
var shellPhysicComponent = new PhysicComponent(shellData.Speed);
var shellLogicComponent = new ShellLogicComponent();
var shellGraphicComponent = new CharGraphicComponent(shellData.DisplayChar, consoleWriter);
var shell = new GameObject(shellInputComponent, shellPhysicComponent,
shellLogicComponent, shellGraphicComponent);
shell.Width = shellData.Width;
shell.Height = shellData.Height;
var fireCommand = new FireCommand(shell);
var serializedGameObjectBuilders = new List <ISerializedGameObjectBuilder>()
{
new StoneBuilder(consoleWriter, stoneData),
new PlayerBuilder(consoleWriter, geometryMathService, fireCommand, playerData),
new EnemyBuilder(consoleWriter, gameObjectLocator, geometryMathService, fireCommand, enemyData),
new WinPlatformBuilder(consoleWriter, gameObjectLocator, geometryMathService)
};
var gameObjectBuilder = new GameObjectBuilder(serializedGameObjectBuilders, gameObjectLocator);
var worldProvider = new WorldProvider(gameObjectBuilder, geometryMathService, consoleWriter);
var world = worldProvider.GetWorld(1);
return(world);
}
void CreateUI()
{
Camera camera = Camera.GetComponent <Camera>();
FontRenderer font = new FontRenderer(Font, "Hello World!", 0);
GameObject nextturn = new GameObjectBuilder()
.AddComponent(new Transform(Vector2.Zero, new Vector2(.2f)))
.AddComponent(new SpriteRenderer(NextTurn, 0))
.AddComponent(new Dimentions(0, 0, 50, 50))
.AddComponent(new Clickable(GlobalScripts.GetComponent <TurnManager>().NextTurn))
.AddComponent(new CameraFollow(camera, Vector2.Zero))
.Register(this);
GameObject infobox = new GameObjectBuilder()
.AddComponent(new Transform(Vector2.Zero))
.AddComponent(font)
.AddComponent(new CameraFollow(camera, new Vector2(0, SceneManager.Instance.ViewportRectangle.Height - 5 * Font.LineSpacing)))
.Register(this);
font.Active = false;
GlobalScripts.GetComponent <Player>().Infobox = font;
}
GameObject CreateItem(Action <Character> effect, string description, int spriteX, int spriteY, int posX, int posY)
{
Player player = GlobalScripts.GetComponent <Player>();
Item itemComponent = new Item(effect);
GameObject item = new GameObjectBuilder()
.AddComponent(new Transform(new Vector2(Map.Size * posX, Map.Size * posY)))
.AddComponent(new SpriteRenderer(Items, new Rectangle(Map.Size * spriteX, Map.Size * spriteY, Map.Size, Map.Size)))
.AddComponent(itemComponent)
.AddComponent(new Dimentions(0, 0, Map.Size, Map.Size))
.AddComponent(new Hoverable(() => player.RequestInfoboxOverride(description, itemComponent),
() => player.InvalidateInfoboxOverride(itemComponent)))
.Register(this);
Map[posX, posY].OccupiedBy = item;
if (Map[posX, posY].Room.View != Room.Visibility.Visible)
{
item.GetComponent <SpriteRenderer>().Active = false;
}
return(item);
}
public void Disable()
{
var source = new GameObject().AddComponent <GameObjectPoolBehaviour>();
source.PoolDisable();
var builder = new GameObjectBuilder <GameObjectPoolBehaviour>(source);
var pool = new GameObjectPoolCollection <GameObjectPoolBehaviour>(builder);
GameObjectPoolBehaviour behaviour = pool.Enable();
behaviour.PoolEnable();
Assert.NotNull(behaviour);
Assert.True(behaviour.IsPoolEnabled());
bool result0 = pool.Disable(behaviour);
behaviour.PoolDisable();
Assert.True(result0);
Assert.False(behaviour.IsPoolEnabled());
}
void CreateMechanics()
{
Camera = new GameObjectBuilder()
.AddComponent(new Transform(Vector2.Zero))
.AddComponent(new Camera())
.Register(this);
GameObject sword = new GameObjectBuilder()
.AddComponent(new Transform(new Vector2(1 * Map.Size, 1 * Map.Size)))
.AddComponent(new SpriteRenderer(Sword, new Rectangle(0, 0, Map.Size, Map.Size), .1f))
.AddComponent(CreateSwordAnimator())
.Register(this);
sword.Active = false;
GlobalScripts = new GameObjectBuilder()
.AddComponent(new Player())
.AddComponent(new MapPanner(Camera.GetComponent <Camera>()))
.AddComponent(new TurnManager())
.AddComponent(new CombatManager(sword))
.Register(this);
GlobalScripts.GetComponent <Player>().Mode = Player.PlayerMode.Thinking;
}
GameObject CreateHero(string name, int spriteX, int spriteY, int posX, int posY, Color col, int speed, int hp, int atk, CombatType type)
{
Hero heroComponent = new Hero(name, GlobalScripts, Map[posX, posY], col, speed, hp, atk, type);
Player player = GlobalScripts.GetComponent <Player>();
GameObject hero = new GameObjectBuilder()
.AddComponent(new Transform(new Vector2(Map.Size * posX, Map.Size * posY)))
.AddComponent(new SpriteRenderer(Chara))
.AddComponent(CreateAnimator(Chara, spriteX, spriteY))
.AddComponent(CreateAnimationStateMachine(Map.Size))
.AddComponent(heroComponent)
.AddComponent(new Dimentions(0, 0, Map.Size, Map.Size))
.AddComponent(new Hoverable(() => player.RequestInfoboxOverride(
"<" + heroComponent.Name + ">" + Environment.NewLine +
"HP: " + heroComponent.HitPoints.Remaining + " / " + heroComponent.HitPoints.Max + Environment.NewLine +
"Speed: " + heroComponent.Speed.Max + Environment.NewLine +
"Strength: " + heroComponent.Strength + Environment.NewLine +
"Type: " + heroComponent.Type,
heroComponent), () => player.InvalidateInfoboxOverride(heroComponent)))
.Register(this);
Map[posX, posY].OccupiedBy = hero;
return(hero);
}
public Player(GameObjectBuilder builder) : base(builder)
{
}
public Platform(GameObjectBuilder builder) : base(builder)
{
}
private GameObject createCardTextureGame(string name, Transform parent, Sprite sprite)
{
GameObjectBuilder builder = new GameObjectBuilder(name, parent);
builder.addSprite(sprite, 1);
return builder.GameObject;
}
public void OneTimeSetUp()
{
fakeLocalPlayer = GameObjectBuilder.New().Build();
fakeRemotePlayer = GameObjectBuilder.New().Build();
}
public Zombie(GameObjectBuilder builder) : base(builder)
{
}
static void Main(string[] args)
{
{
double[][] arr;
arr = new double[3][];
arr[0] = new double[4] {
9, 8, 7, 6
};
arr[1] = new double[4] {
42, 13, 7, 2
};
arr[2] = new double[4] {
101, 102, 103, 104
};
MeshAttributeCLASSES meshComponent2 = MeshAttributeCLASSES.makeDouble4(arr);
double[] readback = meshComponent2.getDouble4Accessor()[1];
int breakPointHere = 42;
}
// test solver for trivial cases
{
double one = 1.0;
double J11 = 1.0, J22 = 1.0, J33 = 1.0, // principal moments of inertia of the body
w1 = 0, w2 = 0, w3 = 0, // angular velocity of spacecraft in spacecraft frame
// result values
q1Dot, q2Dot, q3Dot, q4Dot,
w1Dot, w2Dot, w3Dot,
// coeefficients, taken from the paper
gamma = 0.7,
aCoefficient = 1.25,
d = 7.5, k = 3.0, betaOne = 0.001;
Quaternion spacecraftOrientationError;
// set to identity
/*
* spacecraftOrientationError.i = 0;
* spacecraftOrientationError.j = 0;
* spacecraftOrientationError.k = 0;
* spacecraftOrientationError.scalar = 1;
*/
spacecraftOrientationError = QuaternionUtilities.makeFromAxisAndAngle(new SpatialVectorDouble(new double[] { 1, 0, 0 }), 1.0);
QuaternionFeedbackRegulatorForSpacecraft.calcControl(
J11, J22, J33,
spacecraftOrientationError.i, spacecraftOrientationError.j, spacecraftOrientationError.k, spacecraftOrientationError.scalar,
w1, w2, w3,
out q1Dot, out q2Dot, out q3Dot, out q4Dot,
out w1Dot, out w2Dot, out w3Dot,
aCoefficient,
gamma,
d, k,
betaOne
);
// changes must be zero
Debug.Assert(q1Dot == 0);
Debug.Assert(q2Dot == 0);
Debug.Assert(q3Dot == 0);
Debug.Assert(q4Dot == 0);
Debug.Assert(w1Dot == 0);
Debug.Assert(w2Dot == 0);
Debug.Assert(w3Dot == 0);
int breakPointHere = 42;
}
SimplexSolver simplexSolver = new SimplexSolver();
/* first example from video tutorial, https://www.youtube.com/watch?v=Axg9OhJ4cjg, bottom row is negative unlike in the video
*/
simplexSolver.matrix = Matrix.makeByRowsAndColumns(3, 5);
simplexSolver.matrix[0, 0] = 4;
simplexSolver.matrix[0, 1] = 8;
simplexSolver.matrix[0, 2] = 1;
simplexSolver.matrix[0, 3] = 0;
simplexSolver.matrix[0, 4] = 24;
simplexSolver.matrix[1, 0] = 2;
simplexSolver.matrix[1, 1] = 1;
simplexSolver.matrix[1, 2] = 0;
simplexSolver.matrix[1, 3] = 1;
simplexSolver.matrix[1, 4] = 10;
simplexSolver.matrix[2, 0] = -3;
simplexSolver.matrix[2, 1] = -4;
simplexSolver.matrix[2, 2] = 0;
simplexSolver.matrix[2, 3] = 0;
simplexSolver.matrix[2, 4] = 0;
simplexSolver.iterate();
// result must be ~16.67
Debug.Assert(simplexSolver.matrix[2, 4] > 16.6 && simplexSolver.matrix[2, 4] < 16.8);
// TODO< move into unittest for Matrix >
Matrix toInverseMatrix = new Matrix(2, 2);
toInverseMatrix[0, 0] = 2.0f;
toInverseMatrix[0, 1] = 1.0f;
toInverseMatrix[1, 0] = 2.0f;
toInverseMatrix[1, 1] = 2.0f;
Matrix inversedMatrix = toInverseMatrix.inverse();
Debug.Assert(System.Math.Abs(inversedMatrix[0, 0] - 1.0f) < 0.001f);
Debug.Assert(System.Math.Abs(inversedMatrix[0, 1] - -0.5f) < 0.001f);
Debug.Assert(System.Math.Abs(inversedMatrix[1, 0] - -1.0f) < 0.001f);
Debug.Assert(System.Math.Abs(inversedMatrix[1, 1] - 1.0f) < 0.001f);
// test pid controller
if (false)
{
Pid.Configuration pidConfiguration = new Pid.Configuration();
pidConfiguration.integral = 0;
pidConfiguration.derivative = 0.1;
pidConfiguration.proportial = 0.3;
Pid pid = Pid.makeByTargetAndConfiguration(0, pidConfiguration);
double value = 1.0;
double control;
control = pid.step(value, 0.5);
value += control;
for (int i = 0; i < 10; i++)
{
control = pid.step(value, 0.5);
value += control;
Console.WriteLine("value={0} control={1}", value, control);
}
int breakPointHere0 = 1;
}
EntityManager entityManager = new EntityManager();
SolidResponsibility solidResponsibility;
EffectResponsibility effectResponsibility;
ThrusterResponsibility thrusterResponsibility;
AttitudeAndAccelerationControlResponsibility attitudeAndAccelerationControlResponsibility;
thrusterResponsibility = new ThrusterResponsibility();
attitudeAndAccelerationControlResponsibility = new AttitudeAndAccelerationControlResponsibility(thrusterResponsibility);
effectResponsibility = new EffectResponsibility();
solidResponsibility = new SolidResponsibility();
solidResponsibility.mapping = new PhysicsObjectIdToSolidClusterMapping();
EntityController entityController = new EntityController();
IKeyboardInputHandler keyboardInputHandler = new PlayerShipControlInputHandler(entityController);
KeyboardInputRemapper keyboardInputRemapper = new KeyboardInputRemapper(keyboardInputHandler);
SoftwareRenderer softwareRenderer = new SoftwareRenderer();
PrototypeForm prototypeForm = new PrototypeForm();
prototypeForm.softwareRenderer = softwareRenderer;
IGuiRenderer guiRenderer = prototypeForm.softwareGuiRenderer;
GuiContext guiContext = new GuiContext(guiRenderer);
prototypeForm.guiContext = guiContext;
KeyboardEventRouterOfGui keyboardEventRouterOfGui = new KeyboardEventRouterOfGui(guiContext.selectionTracker);
KeyboardInputRouter keyboardInputRouter = new KeyboardInputRouter(keyboardInputRemapper, keyboardEventRouterOfGui);
prototypeForm.keyboardInputRouter = keyboardInputRouter;
prototypeForm.Show();
PhysicsEngine physicsEngine = new PhysicsEngine();
solidResponsibility.physicsEngine = physicsEngine;
physicsEngine.collisionHandlers.Add(new DefaultCollisionHandler()); // add the default collision handler for absorbing all particles
AttachedForce thruster = new AttachedForce(
new SpatialVectorDouble(new double[] { 0, 1, 0 }), // localLocation
new SpatialVectorDouble(new double[] { 1, 0, 0 }) // localDirection
);
PhysicsComponent physicsComponent;
{
double mass = 1.0;
Matrix inertiaTensor = InertiaHelper.calcInertiaTensorForCube(mass, 1.0, 1.0, 1.0);
physicsComponent = physicsEngine.createPhysicsComponent(new SpatialVectorDouble(new double[] { 0, 0, 10 }), new SpatialVectorDouble(new double[] { 0, 0, 0 }), mass, inertiaTensor);
}
physicsComponent.attachedForces.Add(thruster);
MeshComponent meshComponent = new MeshComponent();
meshComponent.mesh = new MeshWithExplicitFaces();
meshComponent.mesh.faces = new MeshWithExplicitFaces.Face[1];
meshComponent.mesh.faces[0] = new MeshWithExplicitFaces.Face();
meshComponent.mesh.faces[0].verticesIndices = new uint[] { 0, 1, 2 };
{ // create a VerticesWithAttributes with just positions
MutableMeshAttribute positionMeshAttribute = MutableMeshAttribute.makeDouble4ByLength(4);
positionMeshAttribute.getDouble4Accessor()[0] = new double[] { -1, -1, 0, 1 };
positionMeshAttribute.getDouble4Accessor()[1] = new double[] { 1, -1, 0, 1 };
positionMeshAttribute.getDouble4Accessor()[2] = new double[] { 0, 1, 0, 1 };
positionMeshAttribute.getDouble4Accessor()[3] = new double[] { 0, 0, 1, 1 };
VerticesWithAttributes verticesWithAttributes = new VerticesWithAttributes(new AbstractMeshAttribute[] { positionMeshAttribute }, 0);
meshComponent.mesh.verticesWithAttributes = verticesWithAttributes;
}
//TransformedMeshComponent transformedMeshComponentForPhysics = new TransformedMeshComponent();
//transformedMeshComponentForPhysics.meshComponent = meshComponent;
IList <ColliderComponent> colliderComponents = new List <ColliderComponent>();
{
SpatialVectorDouble colliderComponentSize = new SpatialVectorDouble(new double[] { 2, 2, 2 });
SpatialVectorDouble colliderComponentLocalPosition = new SpatialVectorDouble(new double[] { 0, 0, 0 });
SpatialVectorDouble colliderComponentLocalRotation = new SpatialVectorDouble(new double[] { 0, 0, 0 });
ColliderComponent colliderComponent0 = ColliderComponent.makeBox(colliderComponentSize, colliderComponentLocalPosition, colliderComponentLocalRotation);
colliderComponents.Add(colliderComponent0);
}
///physicsEngine.physicsAndMeshPairs.Add(new PhysicsComponentAndCollidersPair(physicsComponent, colliderComponents));
// same mesh for the visualization
TransformedMeshComponent transformedMeshComponentForRendering = new TransformedMeshComponent();
transformedMeshComponentForRendering.meshComponent = meshComponent;
///softwareRenderer.physicsAndMeshPairs.Add(new PhysicsComponentAndMeshPair(physicsComponent, transformedMeshComponentForRendering));
physicsEngine.tick();
// TODO< read object description from json and create physics and graphics objects >
// TODO< read and create solid description from json >
// create and store solids of rocket
// refactored
/*
* if ( true ) {
*
*
* SolidCluster solidClusterOfRocket = new SolidCluster();
*
* // create solid of rocket
* {
* SpatialVectorDouble solidSize = new SpatialVectorDouble(new double[] { 2, 2, 2 });
* double massOfSolidInKilogram = 1.0;
* IList<CompositionFraction> solidCompositionFractions = new List<CompositionFraction>() { new CompositionFraction(new Isotope("Fe56"), massOfSolidInKilogram) };
* Composition solidComposition = new Composition(solidCompositionFractions);
*
* physics.solid.Solid solid = physics.solid.Solid.makeBox(solidComposition, solidSize);
*
* SpatialVectorDouble solidLocalPosition = new SpatialVectorDouble(new double[] { 0, 0, 0 });
* SpatialVectorDouble solidLocalRotation = new SpatialVectorDouble(new double[] { 0, 0, 0 });
*
* solidClusterOfRocket.solids.Add(new SolidCluster.SolidWithPositionAndRotation(solid, solidLocalPosition, solidLocalRotation));
* }
*
* /// TODO, uncommented because it uses the not existing physics object
* /// solidResponsibility.mapping.physicsObjectIdToSolidCluster[rocketPhysicsObject.id] = solidClusterOfRocket;
* }
*/
// add test particle
if (false)
{
SpatialVectorDouble particlePosition = new SpatialVectorDouble(new double[] { 0, 0, 0 });
SpatialVectorDouble particleVelocity = new SpatialVectorDouble(new double[] { 0, 0, 1 });
PhysicsComponent particlePhysicsComponent = physicsEngine.createPhysicsComponent(particlePosition, particleVelocity, 1.0, null);
physicsEngine.addParticle(particlePhysicsComponent);
}
// write game object for TestMissile
if (true)
{
DemoObjectSerializer.seralizeAndWriteShip();
DemoObjectSerializer.serializeAndWriteMissile();
}
GameObjectBuilder gameObjectBuilder = new GameObjectBuilder();
gameObjectBuilder.physicsEngine = physicsEngine;
gameObjectBuilder.softwareRenderer = softwareRenderer;
gameObjectBuilder.solidResponsibility = solidResponsibility;
gameObjectBuilder.effectResponsibility = effectResponsibility;
gameObjectBuilder.thrusterResponsibility = thrusterResponsibility;
gameObjectBuilder.attitudeAndAccelerationControlResponsibility = attitudeAndAccelerationControlResponsibility;
// load missile game object from json and construct it
if (false)
{
GameObjectTemplate deserilizedGameObjectTemplate;
// load
{
List <string> uriParts = new List <string>(AssemblyDirectory.Uri.Segments);
uriParts.RemoveAt(0); // remove first "/"
uriParts.RemoveRange(uriParts.Count - 4, 4);
uriParts.AddRange(new string[] { "gameResources/", "prototypingMissile.json" });
string path = string.Join("", uriParts).Replace('/', '\\').Replace("%20", " ");
string fileContent = File.ReadAllText(path);
deserilizedGameObjectTemplate = GameObjectTemplate.deserialize(fileContent);
}
// build game object from template
Entity createdEntity;
{
SpatialVectorDouble globalPosition = new SpatialVectorDouble(new double[] { 0, 0, 5 });
SpatialVectorDouble globalVelocity = new SpatialVectorDouble(new double[] { 0, 0, 0 });
createdEntity = gameObjectBuilder.buildFromTemplate(deserilizedGameObjectTemplate, globalPosition, globalVelocity);
entityManager.addEntity(createdEntity);
}
// manually add components
{
// TODO< chemical explosive ignition component >
DummyComponent chemicalExplosiveIgnitionComponent = new DummyComponent();
// remap proximityEnter to explode
EventRemapperComponent eventRemapper = new EventRemapperComponent(chemicalExplosiveIgnitionComponent);
eventRemapper.eventTypeMap["proximityEnter"] = "explode";
// TODO< blacklist somehow other missiles >
PhysicsComponent parentPhysicsComponent = createdEntity.getSingleComponentsByType <PhysicsComponent>();
ProximityDetectorComponent proximityDetector = ProximityDetectorComponent.makeSphereDetector(physicsEngine, parentPhysicsComponent, 20.0, eventRemapper);
entityManager.addComponentToEntity(createdEntity, proximityDetector);
}
}
Entity playerShip;
if (true)
{
GameObjectTemplate deserilizedGameObjectTemplate;
// load
{
List <string> uriParts = new List <string>(AssemblyDirectory.Uri.Segments);
uriParts.RemoveAt(0); // remove first "/"
uriParts.RemoveRange(uriParts.Count - 4, 4);
uriParts.AddRange(new string[] { "gameResources/", "prototypingShip.json" });
string path = string.Join("", uriParts).Replace('/', '\\').Replace("%20", " ");
string fileContent = File.ReadAllText(path);
deserilizedGameObjectTemplate = GameObjectTemplate.deserialize(fileContent);
}
// build game object from template
{
SpatialVectorDouble globalPosition = new SpatialVectorDouble(new double[] { 0, 0, 10 });
SpatialVectorDouble globalVelocity = new SpatialVectorDouble(new double[] { 0, 0, 0 });
Entity createdEntity = gameObjectBuilder.buildFromTemplate(deserilizedGameObjectTemplate, globalPosition, globalVelocity);
entityManager.addEntity(createdEntity);
playerShip = createdEntity;
}
}
Entity aiShip = null;
EntityController aiShipController = new EntityController();
VehicleAlignToCommand command = null;
bool withTestAiShip = true;
if (withTestAiShip)
{
GameObjectTemplate deserilizedGameObjectTemplate;
// load
{
List <string> uriParts = new List <string>(AssemblyDirectory.Uri.Segments);
uriParts.RemoveAt(0); // remove first "/"
uriParts.RemoveRange(uriParts.Count - 4, 4);
uriParts.AddRange(new string[] { "gameResources/", "prototypingShip.json" });
string path = string.Join("", uriParts).Replace('/', '\\').Replace("%20", " ");
string fileContent = File.ReadAllText(path);
deserilizedGameObjectTemplate = GameObjectTemplate.deserialize(fileContent);
}
// build game object from template
{
SpatialVectorDouble globalPosition = new SpatialVectorDouble(new double[] { 0, 0, 10 });
SpatialVectorDouble globalVelocity = new SpatialVectorDouble(new double[] { 0, 0, 0 });
Entity createdEntity = gameObjectBuilder.buildFromTemplate(deserilizedGameObjectTemplate, globalPosition, globalVelocity);
entityManager.addEntity(createdEntity);
aiShip = createdEntity;
}
{ // control
aiShip.getSingleComponentsByType <VehicleControllerComponent>().controller = aiShipController;
}
{ // AI initialization
double dt = 1.0 / 60.0;
SpatialVectorDouble targetDirection = new SpatialVectorDouble(new double[] { 1, 0, 0.1 }).normalized();
double targetDerivationDistance = 0.001;
ulong targetPhysicsObjectId = aiShip.getSingleComponentsByType <PhysicsComponent>().id;
command = VehicleAlignToCommand.makeByGettingPidConfigurationFromAttitudeAndAccelerationControlResponsibility(
attitudeAndAccelerationControlResponsibility,
physicsEngine,
dt,
targetDirection,
aiShipController,
targetPhysicsObjectId,
targetDerivationDistance);
}
}
//
{
}
playerShip.getSingleComponentsByType <VehicleControllerComponent>().controller = entityController;
// create test GUI
{
Button button = new subsystems.gui.Button();
button.position = new SpatialVectorDouble(new double[] { 0.2, 0.2 });
button.size = new SpatialVectorDouble(new double[] { 0.3, 0.1 });
button.text = "[Gamesave05-res.save](35)";
button.textScale = new SpatialVectorDouble(new double[] { 0.05, 0.08 });
guiContext.addGuiElement(button);
}
ulong frameCounter = 0;
ulong debugFrameCounter = 0; // used to limit the frames we do for debugging a scenario
bool isFixedScenarioDebugMode = false;
// TODO< use logger >
StreamWriter debugLogFileOfVariables = null; // used to debug variables and coeeficients of the debug scenario
if (isFixedScenarioDebugMode)
{
if (!File.Exists("E:\\myLogShipOrientation.txt"))
{
using (var stream = File.Create("E:\\myLogShipOrientation.txt"));
}
debugLogFileOfVariables = File.AppendText("E:\\myLogShipOrientation.txt");
}
for (;;)
{
Console.WriteLine("frame={0}", frameCounter);
guiContext.tick();
physicsEngine.tick();
if (!isFixedScenarioDebugMode)
{
prototypeForm.Refresh();
Application.DoEvents(); // HACK, EVIL
}
// AI
{
// we just do this small AI because we are testing
if (false && aiShip != null)
{
command.process();
}
}
// AI - attitude control test
// we change the rotation velocity of the spacecraft directly to simulate "perfect" thruster control
{
PhysicsComponent objectOfControlledSpacecraft = aiShip.getSingleComponentsByType <PhysicsComponent>();
double
// principal moments of inertia of the body
// the controller assumes that the body has an inertia tensor like an box, but small derivations are propably fine, too
J11 = objectOfControlledSpacecraft.inertiaTensor[0, 0], J22 = objectOfControlledSpacecraft.inertiaTensor[1, 1], J33 = objectOfControlledSpacecraft.inertiaTensor[2, 2],
// angular velocity of spacecraft in spacecraft frame
w1 = objectOfControlledSpacecraft.eulerLocalAngularVelocity.x,
w2 = objectOfControlledSpacecraft.eulerLocalAngularVelocity.y,
w3 = objectOfControlledSpacecraft.eulerLocalAngularVelocity.z,
// result values
q1Dot, q2Dot, q3Dot, q4Dot,
w1Dot, w2Dot, w3Dot,
// coeefficients, taken from the paper
gamma = 0.7,
aCoefficient = 1.25,
d = 7.5, k = 3.0, betaOne = 0.001;
// calculate the rotation delta to our target orientation from the current orientation
double debugMagnitude = objectOfControlledSpacecraft.rotation.magnitude;
Quaternion spacecraftOrientationError = objectOfControlledSpacecraft.rotation.difference(QuaternionUtilities.makeFromEulerAngles(0, 0.5, 0));
QuaternionFeedbackRegulatorForSpacecraft.calcControl(
J11, J22, J33,
spacecraftOrientationError.i, spacecraftOrientationError.j, spacecraftOrientationError.k, spacecraftOrientationError.scalar,
w1, w2, w3,
out q1Dot, out q2Dot, out q3Dot, out q4Dot,
out w1Dot, out w2Dot, out w3Dot,
aCoefficient,
gamma,
d, k,
betaOne
);
Console.WriteLine(
"w1dot={0}, w2dot={1}, w3dot={2}", w1Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture), w2Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture), w3Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture)
);
if (isFixedScenarioDebugMode)
{
debugLogFileOfVariables.WriteLine("w1dot={0}, w2dot={1}, w3dot={2}", w1Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture), w2Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture), w3Dot.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture));
debugLogFileOfVariables.Flush();
}
// access directly
objectOfControlledSpacecraft.eulerLocalAngularVelocity.x += (w1Dot * (1.0 / 60.0));
objectOfControlledSpacecraft.eulerLocalAngularVelocity.y += (w2Dot * (1.0 / 60.0));
objectOfControlledSpacecraft.eulerLocalAngularVelocity.z += (w3Dot * (1.0 / 60.0));
}
attitudeAndAccelerationControlResponsibility.resetAllThrusters();
entityManager.updateAllEntities();
// order after update is important
attitudeAndAccelerationControlResponsibility.limitAllThrusters();
attitudeAndAccelerationControlResponsibility.transferThrusterForce();
//thruster.forceInNewton = 0.5 * entityController.inputAcceleration;
if (!isFixedScenarioDebugMode)
{
Thread.Sleep((int)((1.0 / 60.0) * 1000.0));
}
if (isFixedScenarioDebugMode)
{
debugLogFileOfVariables.WriteLine("{0},", aiShip.getSingleComponentsByType <PhysicsComponent>().rotation.j.ToString("0.0000", System.Globalization.CultureInfo.InvariantCulture));
debugLogFileOfVariables.Flush();
}
//File.AppendText("E:\\myLogShipOrientation.txt").WriteLine("{0},", aiShip.getSingleComponentsByType<PhysicsComponent>().rotation.y);
if (isFixedScenarioDebugMode && debugFrameCounter >= 8000) // 30000
{
break;
}
debugFrameCounter++;
frameCounter++;
}
}
protected GameObject(GameObjectBuilder builder)
{
PictureBox = builder.pictureBox;
}
public Bullet(GameObjectBuilder builder) : base(builder)
{
}
