Ok, one last thing from our trouble list at the end of day five: Inactive NPCs will still show up.
This is a nice little problem we created for ourselves. The NPCLocation table shows the last known position of any NPC which has ever existed, and we’re not doing any filtering on the
visualizer side to weed out the ones that aren’t there any more. First we’ll inject some code to make this problem more visible:
voidUpdate(){if(Time.time>nextDBUpdate){print("Time to read from the DB! "+Time.time);nextDBUpdate=Time.time+dbUpdateDelta;activeGameRounds.Clear();UpdateCellContents();UpdateWolves();}}voidUpdateWolves(){List<NPC>wolves=DragonsSpine.DAL.DBNPC.GetWolves();print("Wolves? I found: "+wolves.Count);varcellsContainingWolves=newDictionary<Vector3,List<int>>();foreach(NPCwolfinwolves){if(!activeGameRounds.Contains(wolf.lastActiveRound))activeGameRounds.Add(wolf.lastActiveRound);
voidOnGUI(){GUI.Box(newRect(0,0,100,50),"# of cells\n"+map_manager.num_cells);GUI.Box(newRect(Screen.width-100,0,100,50),"# of blocks\n"+map_manager.num_blocks);GUI.Box(newRect(0,Screen.height-50,100,50),"Z top\n"+map_manager.zPlanes[map_manager.currentZTopIdx]);StringBuilderbuilder=newStringBuilder();foreach(intgameRoundinmap_manager.activeGameRounds)builder.Append(gameRound).Append(" ");GUI.Box(newRect(Screen.width-100,Screen.height-50,100,50),"Game Round\n"+builder.ToString());}
There, we’ve given ourselves a way of keeping track of the last-active game rounds of all the NPCs (well, wolves) we’re rendering. Let’s see how that turns out:
As a first step, at least we can render the non-active ones as “ex” wolves. Let’s use a pair of Materials in the Resources directory and assign the appropriate one to the wolf’s Renderer:
voidUpdateWolves(){MaterialliveWolf=Resources.Load("Materials/Wolf",typeof(Material))asMaterial;MaterialexWolf=Resources.Load("Materials/exWolf",typeof(Material))asMaterial;List<NPC>wolves=DragonsSpine.DAL.DBNPC.GetWolves();print("Wolves? I found: "+wolves.Count);varcellsContainingWolves=newDictionary<Vector3,List<int>>();intmaxGameRound=0;foreach(NPCwolfinwolves){if(wolf.lastActiveRound>maxGameRound)maxGameRound=wolf.lastActiveRound;}foreach(NPCwolfinwolves){if(!activeGameRounds.Contains(wolf.lastActiveRound))activeGameRounds.Add(wolf.lastActiveRound);Vector3cell=newVector3(wolf.X,wolf.Y,wolf.Z);wolfLocations[wolf.worldNpcID]=cell;if(!cellsContainingWolves.ContainsKey(cell))cellsContainingWolves[cell]=newList<int>();cellsContainingWolves[cell].Add(wolf.worldNpcID);Vector3position=newVector3((-1f)*wolf.X,(-1f)*wolf.Y,(0.1f*wolf.Z)+0.2f);if(wolfTransforms.ContainsKey(wolf.worldNpcID)){wolfTransforms[wolf.worldNpcID].position=position;}else{Transformtempts=Instantiate(wolfPrefab,position,Quaternion.identity)asTransform;wolfTransforms[wolf.worldNpcID]=tempts;}Rendererrend=wolfTransforms[wolf.worldNpcID].GetComponent<Renderer>();if(wolf.lastActiveRound>=maxGameRound-1)// one round leeway in case we catch the DB in mid-updaterend.material=liveWolf;elserend.material=exWolf;}
This might work, but testing it proved…time-consuming. I restarted the server, and no wolves expired within the first couple hundred rounds. Let’s see if anything else is more fragile:
voidUpdate(){if(Time.time>nextDBUpdate){print("Time to read from the DB! "+Time.time);nextDBUpdate=Time.time+dbUpdateDelta;activeGameRounds.Clear();UpdateCellContents();UpdateNpcs("boar");UpdateNpcs("crocodile");UpdateNpcs("orc");UpdateNpcs("wolf");}}voidUpdateNpcs(stringnpcName){MaterialliveNpc=Resources.Load("Materials/"+npcName,typeof(Material))asMaterial;MaterialexNpc=Resources.Load("Materials/ex"+npcName,typeof(Material))asMaterial;List<NPC>npcs=DragonsSpine.DAL.DBNPC.GetNpcs(npcName);print("I found "+npcs.Count+" NPCs called "+npcName);varcellsContainingNpcs=newDictionary<Vector3,List<int>>();foreach(NPCnpcinnpcs){if(npc.lastActiveRound>maxGameRound)maxGameRound=npc.lastActiveRound;}foreach(NPCnpcinnpcs){if(!activeGameRounds.Contains(npc.lastActiveRound))activeGameRounds.Add(npc.lastActiveRound);Vector3cell=newVector3(npc.X,npc.Y,npc.Z);npcLocations[npc.worldNpcID]=cell;if(!cellsContainingNpcs.ContainsKey(cell))cellsContainingNpcs[cell]=newList<int>();cellsContainingNpcs[cell].Add(npc.worldNpcID);Vector3position=newVector3((-1f)*npc.X,(-1f)*npc.Y,(0.1f*npc.Z)+0.2f);if(npcTransforms.ContainsKey(npc.worldNpcID)){npcTransforms[npc.worldNpcID].position=position;}else{Transformtempts=Instantiate(npcPrefab,position,Quaternion.identity)asTransform;npcTransforms[npc.worldNpcID]=tempts;}Rendererrend=npcTransforms[npc.worldNpcID].GetComponent<Renderer>();if(npc.lastActiveRound>=maxGameRound-1)// one round leeway in case we catch the DB in mid-updaterend.material=liveNpc;elserend.material=exNpc;}// Any cohab?foreach(Vector3cellincellsContainingNpcs.Keys){intpopulation=cellsContainingNpcs[cell].Count;print("Cell "+cell+" has "+population+" of npc "+npcName);intdimension=(int)Math.Ceiling(Math.Sqrt(population));print("We can fit those in a "+dimension+"x"+dimension+" grid.");introw=0,column=0;foreach(intnpcIdincellsContainingNpcs[cell]){print(npcName+" "+row+","+column+" is "+npcId);npcTransforms[npcId].localScale=newVector3(1.0f/dimension,1.0f/dimension,npcTransforms[npcId].localScale.z);Vector3position=newVector3((-1f)*cell.x,(-1f)*cell.y,(0.1f*cell.z)+0.2f);// start at the center of the cellposition+=newVector3(0.5f,0.5f,0f);// move to cornernpcTransforms[npcId].position=position-newVector3(column*(1.0f/dimension),row*(1.0f/dimension),0f);npcTransforms[npcId].position-=newVector3((1.0f/dimension)/2f,(1.0f/dimension)/2f,0f);column+=1;if(column>=dimension){column=0;row+=1;}}}}
A little bit of variety.
Some public domain images and a lot of search-and-replace, and we now handle the NPCs generically and can track four of the common surface types. Different types in the same cell won’t look right, so that’s another TODO.
It may seem strange, the effort I went to in order to show that we were showing stale NPCs. I usually want to clearly show a bug occuring before implementing a fix, or else how do you know it’s fixed?
Usually there’s some learning along the way, especially if it involves unfamiliar tech or a legacy codebase. Automated tests are another, often better, way of addressing this concern. We’ll get to that soon.
