Här är en bildkompilation som visar slutresultatet samt en trailer!

Förutom det så finns möjligheten att ladda ned spelet längst ned.

Spelet!!! ( Obs 110 megabyte)

Ps. Det finns en risk att spelkaraktären försvinner vid dödsfall eller byte från Egypten till Grekland, om så är fallet gå bara ut till menyn och tryck ”Continue” för att fortsätta som om inget hänt.

Jag gjorde det ganska standard med ett Parent – Child system där varje förändring till Föräldern(Parent) ärvs av alla Barn(Child) till denna.
Problemet som uppstår här är hur ofta uppdateringar skall ske till dessa. Eftersom min motor är uppbyggd så att objekt som skall ritas ut är separerade ifrån de som uppdaterar, kändes det smart att lägga det på hämtningen av matriser.

Resultatet blir att varje gång en matris hämtas, uppdateras den om det behövs och alla Childs får sin egen uppdatering i samma veva.
Det verkar smart ända tills man upptäcker att systemet har en flaw, objekt som inte syns uppdaterar inte sina matriser, uppdaterar därför aldrig sina Boundingboxes(som används för att bestämma om objektet syns) och stannar osynliga kvar på punkten där dom tidigare var, tills dom återigen blir synliga.

Lösningen på det blev att alltid förflytta BoundingBoxes.

Vart är du påväg undrar du nu som läsare
Efter att ha arbetat lite med Unity fick jag inspiration till att plocka upp detta igen och fundera vidare.
Ressultatet blev detta.

/// <summary>
/// The combined, Position, Scale and Rotation of an Object.
/// </summary>
/// <typeparam name="T">The Owner / Object that this Transform belong to.</typeparam>
class Transform<T>
{
#region Fields

internal Boolean NeedUpdate; //Is this Transform and its Children in need of an Update?

internal T Owner;       //Owner of this Transform
Transform<T> Combine;   //The Combined Transform of this and the Parent;
Transform<T> Parent;    //The Parent Transform of this;
Transform<T>[] Children;  //Child Transforms of this;
int ChildItterator;

Matrix DrawMatrix;      //The Drawmatrix of the Combine;
Boolean NewDraw;        //if True, a new DrawMatrix will be calculated;

#endregion

#region Properties

/// <summary>
/// The Position of this Object.
/// </summary>
public Vector3 Position
{

set
{
Position = value;
AddChangeLog();
}
get
{
return Combine == null ? Position : Combine.Position;
}
}

/// <summary>
/// The Scale of this Object.
/// </summary>
public Vector3 Scale
{

set
{
Scale = value;
AddChangeLog();
}
get
{
return Combine == null ? Scale : Combine.Scale;
}
}

/// <summary>
/// The Rotation of this Object.
/// </summary>
public Quaternion Rotation
{

set
{
Rotation = value;
AddChangeLog();
}
get
{
return Combine == null ? Rotation : Combine.Rotation;
}
}

/// <summary>
/// The index this child has in its parents child array.
/// </summary>
internal int ChildIndex
{
get;
set;
}
#endregion

#region Initialization

/// <summary>
/// Private Constructor of a Transform used in operator calculations.
/// </summary>
/// <param name="owner"></param>
private Transform(T owner)
{
Owner = owner;
NeedUpdate = true;//By Assigning the NeedUpdate to True. We avoid uneccessary Additions to the Update.
}

/// <summary>
/// Creates a new Transform.
/// </summary>
/// <param name="owner">Owner of this Transform</param>
/// <param name="parent">The Parent of this Transform, send null if there is no parent</param>
public Transform(T owner, Transform<T> parent)
{
Owner = owner;
Parent = parent;

Initialize();
}

/// <summary>
/// Initializes the Transform with default values.
/// If there is a parent, the combined Transform of this and that is determined.
/// </summary>
private void Initialize()
{
Position = Vector3.Zero;
Rotation = Quaternion.Identity;
Scale = Vector3.One;
NewDraw = true;
NeedUpdate = false;

if (Parent == null)
{
Combine = this * Parent;
}
else
{
Combine = new Transform<T>(Owner);
Combine.Position = Position;
Combine.Scale = Scale;
Combine.Rotation = Rotation;
}
}

#endregion

#region Methods

/// <summary>
/// Returns the Combined Transform as a DrawMatrix.
/// </summary>
public Matrix GetDrawMatrix()
{
if (NewDraw)
CalcDrawMatrix();

return DrawMatrix;
}

/// <summary>
/// Calculates a new DrawMatrix using the Combine Transform;
/// </summary>
private void CalcDrawMatrix()
{
DrawMatrix = Matrix.CreateScale(this.Scale);
DrawMatrix *= Matrix.CreateFromQuaternion(this.Rotation);
DrawMatrix.Translation = this.Position;
NewDraw = false;
}

/// <summary>
/// Add a child to this Transform.
/// The child will inherit any changes to this Transform.
/// </summary>
/// <param name="child"></param>
public void AddChild(Transform<T> child)
{
if (Children == null)
{
Children = new Transform<T>[10];
ChildItterator = 0;
}

Children[ChildItterator] = child;
child.ChildIndex = ChildItterator;
ChildItterator++;
}

/// <summary>
/// Removes an exsisting child from the Transform.
/// </summary>
/// <param name="child"></param>
public void RemoveChild(Transform<T> child)
{
ChildItterator--;
Children[ChildItterator].ChildIndex = child.ChildIndex;
Children[child.ChildIndex] = Children[ChildItterator];
Children[ChildItterator] = null;
}

/// <summary>
/// Update the Childs of this Transform.
/// </summary>
/// <param name="parentTransform"></param>
private void UpdateChild(Transform<T> parentTransform)
{
Parent = parentTransform;

//Ensure that we have a parent.
if (Parent != null)
Combine = this * parentTransform;

for(int i = 0; i < ChildItterator; ++i)
{
Children[i].UpdateChild(Combine == null ? this : Combine);
}
NewDraw = true;
NeedUpdate = false;
}

/// <summary>
/// Force the Transform to Update itself and all its children Children.
/// </summary>
public void UpdateYourself()
{
UpdateChild(Parent);
}

/// <summary>
/// Add the Transform to the UpdateChain.
/// </summary>
private void AddChangeLog()
{
//Check so we have not already added the transform.
if (!NeedUpdate)
{
Transform<T>.AddTransformUpdate(this);
NeedUpdate = true;
}
}

//public override bool Equals(object obj)
//{
//    if (obj == null)
//        return false;
//    Transform<T> _check = obj as Transform<T>;
//    if (_check == null)
//        return false;

//    return _check.Owner.Equals(Owner);
//}

/// <summary>
/// Determins if the owners of this and another Transform are the same.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public bool Equals(Transform<T> obj)
{
return obj.Owner.Equals(Owner);
}

/// <summary>
/// Determins if the owner and the owner of this Transform are the same.
/// </summary>
/// <param name="owner"></param>
/// <returns></returns>
public bool Equals(T owner)
{
return Owner.Equals(owner);
}

#endregion

#region Static Functions

/// <summary>
/// Operator handling multiplies of one transform and another.
/// The Transform first Transform is assignedd as the Owner.
/// </summary>
public static Transform<T> operator *(Transform<T> a, Transform<T> b)
{
Transform<T> _returnValue = new Transform<T>(a.Owner);
_returnValue.Position = a.Position + b.Position;
_returnValue.Scale = a.Scale * b.Scale;
_returnValue.Rotation = Quaternion.Concatenate(a.Rotation, b.Rotation);

return _returnValue;
}

/// <summary>
/// An array containing transform objects in need of Update.
/// </summary>
private static Transform<T>[] m_transforms = new Transform<T>[10];
/// <summary>
/// Iterator used to fill and determin the amount of Transforms in need of update.
/// </summary>
private static int m_transformIterator = 0;

/// <summary>
/// Add a Transform to be Updated next time UpdateTransforms() is invoked.
/// </summary>
/// <param name="needUpdate">The Transform to be Updated</param>
private static void AddTransformUpdate(Transform<T> needUpdate)
{
if (m_transformIterator == m_transforms.Length)
Array.Resize(ref m_transforms, m_transforms.Length + 100);

m_transforms[m_transformIterator] = needUpdate; //Assign the Transform in need of update, to the current spot in the Transforms Array.
m_transformIterator++; //Increase
}

/// <summary>
/// Updates all the Transforms that have changed.
/// </summary>
public static void UpdateTransforms()
{
for (int i = 0; i < m_transformIterator; i++)
if (m_transforms[i].NeedUpdate)
m_transforms[i].UpdateYourself();
m_transformIterator = 0;
}

#endregion
}

Försökte ha kvar Formateringen, men den verkar förlorad.
Summan av det hela är denna i alla fall:
Unity har sitt eget Transform objekt knutet till alla GameObjects.
När jag skapade Hierarki Systemet till Brutalson gjorde jag det i bas objektet för utritning.
Nackdelen med det var att jag inte hade särskilt mycket kontroll över det och alla transformeringar var knutna till bas objektet. Något som inte alltid är bäst.

Det här systemet fungerar istället med ett Template. Där ägaren bestäms i början när Transform Objektet skapas.
Sedan när en förändring sker, istället för att updateras först när Matrisen hämtas, läggs den automatiskt till i en loop för uppdateringar.

Denna loopen måste såklart kallas på utifrån, men det är mycket effektivare än att varje förändring beräkna om allt nödvändigt.
En annan fördel är att objekt som redan uppdaterats på grund av deras Parent effektivt plockas bort ifrån extra beräkningar.

Att sedan hämta ut WorldMatrisen för användning vid utritning, är en baggis, det är bara att be om den så for du den senaste.
Har ingen förändring skett till Transformen skickas existerande, annars beräknas en ny.

Hoppas detta kan komma till användning för andra

Hittintills har vi gjort två områden, Egypten och Grekland, i den sista delen innan vi avslutar projektet är att finslipa det vi redan har.
Detta kommer till största del handla om att göra om Egypten, detta då storleken på banorna helt enkelt var för stora för att fyllas.

Här kommer några bilder ifrån spelets utveckling och några skärmdumpar.

Tanken är att du som viking har råkat falla bakåt i tid och rum, vilket fått dig att hamna i Egypten, varifrån du sedan tar dig vidare till Grekland, varav vi rundar av storryn.
Som kan ses i bilderna skiljer sig utseendet avsevärt på banornas upplägg, där Egypten har stora öppna ytor, har Grekland tätare mellan alla objekt.
Vi tänker nu försöka göra något likadant på Egypten och förhoppningsvis blir resultatet det önskvärda.

Temat den här gången var Agent eller Agens, jag teamade ihop med Jonas Gransing.
Våran tolkning av temat blev ett spel där du är en agent åt artister och sport stjärnor, för att hantera deras kontrakt och arbeten.

På bilden syns längst till vänster, ett porträtt av din nuvarande klient, och ditt mål är då att träffa en av de ”jobbmöjligheter” som uppstår och kommer ifrån den övre högra sidan och rör sig mot vänster.
Du springer själv i motsatt riktning och spelets tempo ökar desto fler klienter du hjälpt. Du har däremot bara en begränsad tid på dig med varje klient, annars väljer dom en annan agent. Det är svårigheten, att balansera hastighet och effektivitet.

Gamejam 2010

Ladda ned spelet ( 11 meg )

Zinc

Detta gjorde jag och Jonas Gransing som en förproduktion till vårat nuvarande kandidatarbete.
Målet var att testa många av de mekaniker som skulle användas senare, kollision, event och liknande.

Resultatet blev ett kort men fungerande spel, där du springer runt och skjuter eller spränger zombier.

Som vanligt började vi med att förändra positionen förhållande till spelarens vilja, trycker spelaren på framåt knappen rör sig karaktären ditåt. Efter lite betänketid och implementering av attacker till karaktären, börjar det dock bli aktuellt att skapa ett mer avancerat system. Anledningen till detta är hur  och vilka, som kan påverka själva förflyttningen.

Vad vi vill uppnå är att spelaren skall påbörja en attack, som sedan kan förändra spelarens rörelse. Springer jag framåt och trycker attack, ja då vill vi uppnå att spelaren attackerar, men sedan följer det up med en ny rörelse.

Det nya systemet kommer istället att använda sig av olika RörelseAlternativ.

• Framåt
• Bakåt
• Sidled
• Hopp
• Luftburen
• etc..

Inför varje attack, kollas sedan karaktärens rörelse jämfört med attackens krav på rörelse. Vid påbörjad attack returneras sedan en ny rörelse.

Detta skall då skapa kedjor av attacker där spelaren väljer ingångs punkt, utifrån vilket karaktären tar över och rör sig efter spelarens fortsatta attack kommandon.

Varje påbörjad attack utförs under en viss tid, modifierat av vapen och hastighet. Under attackens gång har spelaren sedan en öppning att fortsätta attacken, lyckas spelaren med detta väljs den mest passande attacken, utifrån vilken sedan en rörelse uppstår och kedjan kan fortlöpa.

Det är ett multiplayer spel ämnat för internet där spelaren registrerar sig på en sida och sedan spelar med sin egen profil för ära och berömmelse

Zonen plockas genom att samla ett högre antal av dina lagmedlemmar inom dess area.
Efter att ha plockat zonen ökar sedan lagets poäng och slutligen(vid 200 poäng) vinner ett av lagen rundan, ett poäng ges till laget som van och en ny runda startar.
Laget som först får 3 raka vinster vinner spelomgången.

För att både försvara sig och spela offensivt har spelaren en ljus-disk, denna skjuts iväg framåt, passerar den sedan vissa portaler på vägen förändras dess attributer.
Den kan till exempel, öka hastighet, minska hastighet för att sedan explodera, eller splittras i 3 nya diskar.
Alla spelare som kolliderar med disken och är av motsatt lag blir sedan ”eliminerade”.

Ett youtube clip som visar spelet.

Spelet skapades under 10 veckor av.

Adam Westman : Programmerare.
Anton Svensson : Programmerare.
Christoffer Torshall : Programmerare.

Jonas Gransin : Grafiker / Designer.
Stefan Gökstorp : Grfiker / Designer / Level Designer.

Mario Gryth : Ljud Designer.

Motorn fick under blocket denna funktionalitet som skulle vara grunden för fortsatt arbete.

• Multi-Threading : Hur de olika kärnorna på processorn kan arbeta med olika uppgifter samtidigt för ökad prestanda, detta effektiviserar bland annat förflyttning och fysik.
  Detta löste jag med ett MessageBuffer system, där spelet är uppdelad i två processer, utritning och updatering. För att kommunicera mellan dessa skickas sedan meddelanden.
• Mesh-Instancing: I ett spel ritas det ofta ut flera exemplar av samma modell och bild, för att effektivisera den processen kan man då använda sig av Hardware Mesh-Instancing.
  En teknik där modellen i princip kopierar sig själv till ett flertal olika ställen och bara ändrar position, rotation och skala.
• Octree : När vi förflyttar oss igenom en digital värld är målet att rita ut så få objekt som möjligt, men ändå visa alla som borde synas. Processen att beräkna vilka som skall synas och inte är en väldigt krävande del.
  En effektiv metod att underlätta detta är ett octree, en teknik där världen delas upp i kuber och mängden objekt som måste gås igenom minskas radikalt, med påföljden snabbare process.

Screenshot ifrån spelet gjort för redovisning av Block1

Stress-test av Mesh-Instansiering, 2,4 milioner polygoner i bild.

Vi har haft två kurser, en 15 veckors kurs där vi lärde oss 3D samt en kurs på 5 veckor som varit kring Beteende och Gameplay i spel.

Här visar jag en kompilation av screenshots tagna under och efter varje ”spelprojekt” jag gjort under hösten och nu de första 5 veckorna av året.

Jag kommer göra en post för vardera ett av spelen inom kort samt länkning till filmer som visar de flesta av dem.
Men det jag kan skriva nu är att, det vi lärt oss kortfattat, det är, 3D programmering, AI, optimering och paketering.

Så vi har lärt oss hur vi tillverkar ett spel i 3D där det finns Datorstyrda fiender eller vänner, som styrs med hjälp av Artificiell Intelligens.
Ett system som använder sig av beteenden, states, där dom reagerar på omgivningen och ändrar beteenden i förhållande till det som sker.
Optimeringen har involverat hur vi använder om kod bitar vi annars upprepade, val av vad som skall ritas ut och vad som inte skall, inladdning av data med hjälp av threads.
Samt en hel del andra optimerings delar.
Paketering involverar meny system, teman, helt enkelt, att få en slutprodukt som går att presentera för andra, och inte bara ser ut som ett annat techdemo.

YoutubeFilm på Irrbloss, ett av de spelen jag gjort under de gångna kurserna

Vad skall vi då göra? ett Hack and Slash i 3D blir det, ämnat till pc först och främst.

Som det ser ut nu kommer det handla om en viking som råkat förflytta sig i både tid och plats, under resan till ett nytt ställe att plundra.
Features som spelet kommer innehålla är bland annat att kunna plocka upp vapen, combo-system för attacker där timing och reaktioner påverkar resultatet av en strid.

Jag arbetar som enda programmerare på projektet tillsammans med tre andra designers(Jonas Gransing, Tommie Malmgren och Mikael Palm) och en inhyrd ljud designer( Mario Gryth).
Vi har alla olika arbetsuppgifter att arbeta med, men vi kommer att arbeta med min motor som jag utvecklat under mina 15 veckor fördjupning som avslutades med spelet Zinc(Zombie Invasion North Carolina) som jag och Jonas arbetade på över julen. Hitintills ser det ut att gå bra med projektet, vi lärde oss mycket under fördjupningen och det vill vi nu ta vara på och visa upp i kandidaten.

Min uppgift i projektet kommer därför bli att utveckla motorn i de områden där det nu saknas funktioner, men också att skapa alla spelrelaterade funktioner och objekt för användning i Editorn som Mikael sedan kommer använda för att skapa världen våran Viking skall ta sig igenom.
I sitt arbete att forma världarna har Mikael, Jonas och Tommie. Jonas kommer att fokusera på att skapa Animerade Modeller och Tommie kommer fokusera på att göra propps, dessa inkluderar träd, stenar, hus, vapen och liknande.

Så med denna uppdatering lämnar jag en fin bild att begrunda.

( Det är våran temporära spelare i färd som består av två hopkopplade modeller, däremot har de inte riktigt hittat varandra än… )