I'm doing some charts with analytics regarding a game. Here is the basic assumptions.
There are three possible actions a player can make.
Player can attack
Player can deffend
Player can run ( in 2 directions forwards and backwards)
Each action can happen in one of the three battlegrounds (bg a, bg b, bg c)
A player can be human or alien. Each player regarding of race can have a level.
Each player executes a particular action at a particular time.
Now i need to chart these things.
Piechart of the players race
Piechart of where the actions took place(in which of the 3 battlegrounds)
A barchart of the players level
A line chart for attacks based on time
A line chart for defends based on time
A linechart for runs( oneline for each direction of running) based on time
Each chart needs to be connected to the other ones (kondof the crossfilter flight charts are) . So for example if i click on the piechart with the player race and chose human the other charts update accordingly to reflect levels, and battlegrounds and actions pertaining just to that race.
Bottom line is i am having a hard time structuring my json input. Can any experts give me some hints?
Thank you for your time.
As I see it, the most flexible way is to build up an array of "events" (an event can be anything a player might do) with timestamps. Something like:
var playerEvents = [
{ timestamp: 1352848500, player:'human', action:'attack', location:'bg A' },
{ timestamp: 1352848600, player:'alien', action:'run', meta:'dir=left', location:'bg B' },
....
]
Once you have that, any stats you want display would involve filtering this array of events down to whatever you need for the given graphic.
Related
I'm simulating the operation of a railroad.
I have a table with train departure time, departure location, and arrival location data. Locations are given using longitude and latitude coordinates.
I created my rail yards on the GIS map using their coordinates.
I can make the trains depart following the schedules in the table and the correct departure location.
But I can't get them to go to the right destination.
When trying to use the moveTo block you can only indicate a single destination. In my simulator, each train will go to a different yard.
How can I perform this movement using a data table and geographic coordinates?
Some pertinent remarks:
I'm not using the rail library. I'm working in the GIS space with routes determined by Anylogic itself. I didn't design or import railroads.
For this reason, I'm using the "source" and "moveTo" blocks from the process modeling library.
In the "moveTo" block I didn't find options that allow me to use the longitude and latitude data of the destination and which are stored in the data table (as I do in the "source" block).
Whenever I try to insert some code that does this, Anylogic returns saying the error:
"Exception during discrete event execution:
root:
Non-unique value in the database!"
It is better to rather use an agent-based approach for this kind of movement instead of doing it using move to blocks. It is hard to explain here but do some more tutorial examples and you will understand. You want the agents to move at a specific time and in a process flow modelling approach unless you use delay or hold blocks agents will flow from one block to the next as soon as there is space.
Here is an example of how to do it using the agent-based approach using your setup.
I have an agent called Trem with a dynamic event to move it to a specific location.
Now we populate the dynamic events with data from the database at the start of the model using the code below.
List<Tuple> rows = selectFrom(db_table)
.list();
for (Tuple row : rows) {
//What is the start time of the movement
double timeToTripBegin = dateToTime(row.get( db_table.trip_begin_time ));
//Lets create a new movement event to trigger the movement in the future
create_MoveToLocation(timeToTripBegin,
row.get( db_table.latitude_chegada ),
row.get( db_table.longitude_chegada ));
}
These events will then trigger the required movement for us when the event executes.
In a Cesium CZML Model, I'd like to define multiple clocks, each one with its own time interval and multiplier, something like:
clock: {
interval: "2019-06-01T16:00:00Z/2019-06-01T16:10:00Z",
currentTime: "2019-06-01T16:00:00Z",
multiplier: 60,
range: "UNBOUNDED",
step: "SYSTEM_CLOCK_MULTIPLIER",
},
clock: {
interval: "2019-06-01T16:10:00Z/2019-06-01T16:20:00Z",
currentTime: "2019-06-01T16:10:00Z",
multiplier: 80,
range: "UNBOUNDED",
step: "SYSTEM_CLOCK_MULTIPLIER",
},
but this is not possible, because clock would be a duplicate key.
Is there a way to define consecutive time intervals, each one with its own clock multiplier?
Unfortunately I think the answer is "no", at least within a single CZML document. However, Cesium Viewer supports loading multiple DataSources at the same time, so you may load multiple CZML documents concurrently, and each will have its own clock settings.
Cesium.Viewer has a constructor option called automaticallyTrackDataSourceClocks that will cause it to update its own clock settings whenever a new dataSource (separate CZML file) is added, and when the active dataSource is removed. It also has a field, viewer.clockTrackedDataSource that is read/write, and can be used to set which dataSource is currently in charge of the viewer's clock settings.
But, you would need to write your own UI to show a list of available dataSources, and select which one controls the clock settings, if that's what's needed here. Cesium will not automatically jump from the end of one clock range to the start of the next, unless you write code to make this happen.
The viewer will always try to show objects from all dataSources that have "availability" during the current time range, even if the clock is tracking a range from another dataSource. When the time ranges overlap, users will see all objects from multiple dataSources together in the scene. When time ranges don't overlap, expired objects won't be shown, but some "permanent" objects such as stationary points may have infinite availability, and so continue to be shown outside of their parent dataSource's clock range. This can be controlled from within a CZML document by limiting such entities to have availability only within their own file's clock ranges.
I'm using AS3, but general programming wisdom unspecific to AS3 is great too!
I am creating my first game, a top-down dungeon crawler with tile-based navigation, and I am deciding how to store my maps. I need to be able to access a specific tile at any point in time. My only thought so far is to use nested Vectors or Arrays with the first level being the row and the second being the column, something like this:
private var map:Array = new Array(Array(0,1,0,0,1,1,0),Array(0,1,0,1,0,1,0));
private var row2col3:uint = map[1][2];
/*map would display as such:*/
#|##||#
#|#|#|#
Ultimately, the idea is to build a Map class that will be easily extensible and, again, allow free access to any specific tile. I am looking for help in determining an effective/efficient design architecture for that Map class.
Thanks!
As stated in the comments I would upload and give my source code for a 12 hour challenge project to create a tile based level editor. The source code can be found at: GitHub BKYeates
This level editor focuses on textures being a power of 2, and uses blitting for drawing on all the textures. It can read, write, and store partial tiles. There is also some functionality to erase and draw on collision boxes.
Now in regards to how the storage should be setup, it is really up to you. If you are going to be storing lots of information I recommend using Vectors. Vectors perform faster than most other container types except for ByteArray (if used correctly). In my level editor I used a Vector with a particular setup.
The Vector I used named _map in a class called tilemodel. tilemodel is responsible for updating all the storage information when a change is made. The _map variable is setup like so:
_map = new Vector.<Vector.<Vector.<Object>>>();
This is a pretty heavily nested Vector and in the end stores, can you believe it, an Object! Which admittedly really chunks out the performance gains you get from using Vector when you are indexing the furthest nested elements.
But ignore that because the indexing gain from this setup is really key. The reason it is setup this way is because I can reference a layer, a row, and a column to grab a specific tile object. For example, I have a tile on layer 2 in row 12 column 13 that I want to access:
var tileObject:Object = _map[2][12][13];
That works perfectly for pretty much any scenario I could use in my tile based game, and the speed is comparatively better than that of a Object or Dictionary when this is being accessed multiple times (i.e. - in a loop which happens often).
The level editor is designed to use all blitting and leave onus to my management classes for storage. The speed gain from doing this is very high, and the way it is currently setup the tilemodel can store partial bitmaps making it slightly more flexible than your standard rigidness of a power of 2 texture reader.
Feel free to look through the source code. But here is a summary of what some of the classes do:
tilecontroller - Issues state changes and updates to tilemanager and tilemodel
tilemanager - Responsible for texture drawing and removal.
tilemodel - Stores and updates the current map on state changes.
r_loader - Loads all assets from assetList.txt (paths set to images
there).
hudcontroller - Currently this was the last thing I was working on, lets you draw on collision boxes that are stored in a separate file alongside the map.
g_global & g_keys - Global constants and static methods use
ubiquitously
LevelEditor - Main class, also designed as "View" class ( see MVC pattern: MVC Pattern )
Also as I've mentioned it can read back all the storage. The class used for that I did not upload to GitHub, but figured I would show the important method here:
//#param assets needs to be the list of loaded bitmap images
public function generateMap( assets:* ):void {
var bmd:BitmapData = new BitmapData( g_global.stageWidth, g_global.stageHeight, true, 0 );
_canvas = new Bitmap( bmd, "auto", true );
_mapLayer.addChild( _canvas );
_canvas.bitmapData.unlock();
g_global.echo( "generating map" );
var i:int, j:int, m:int;
for ( m = 0; m < _tiles.length; m++ ) {
for ( i = 0; i < _tiles[m].length; i++ ) {
for ( j = 0; j < _tiles[m][i].length; j++ ) {
//wondering why im type casting in this evaluation? _tiles[i][j].tile == int( _tiles[i][j].tile )
//the level editor stores tiles that are larger than the grid size at indices containing values that are a percent of the tile size
var tile:Object = _tiles[m][i][j];
if ( tile != null && int( tile.tile ) == tile.tile ) {
addTile( g_global.GRIDSIZE * tile.column, g_global.GRIDSIZE * tile.row, { index:tile.tile, bitmap:assets[ tile.tile ] }, tile.rotation );
}
}
}
}
_canvas.bitmapData.lock();
}
Anyway I hope this information finds you well. Good luck!
I asked a similar question a while back: https://gamedev.stackexchange.com/questions/60433/is-it-more-efficient-to-store-my-tile-grid-as-a-dictionary-or-an-array. I'm not sure that it would really matter whether it's an Array or a Vector (the differences in efficiency seem to differ between FP versions, etc.).
But, yeah, you probably want to use one or the other (not a Dictionary or anything), and you probably want to index it like [y * width + x], not [x][y]. Reasons: Efficiency and not having overly complicated data structures.
Also if you need to be able to regularly access the Array or Vector outside of that class, just make the variable internal or public or whatever; making it private and wrapping over it with functions, while being more prim-and-proper class design, would still be overkill.
One method I am using right now for my own thing is that I'm storing my tiles in a black and white pixel bitmap (and wrote a wrapper around that). I'm not sure how efficient this is overall as I've never benchmarked it and just wrote it quickly to create a map for testing purposes, but I am finding that it does offer an advantage in that I can draw my maps in an image editor and view them easily while still allowing random pixel/tile access.
Looking at your sample code, I'm guessing you have only two types of tiles right now, so you could just use black and white pixels as well if you want to try it.
I've done the 2d array method as well (using it still actually for other parts) which works fine too, but perhaps can be harder to visualise at larger sizes. Looking forward to Bennett's answer.
I am busy with building a kind of 'track' player for GPS Tracks.
I have in my database all the positions of a certain track (latitude, longitude, altitude, time).
I am able to display the whole track on a map and move the marker along that track (see http://89.188.9.68/nl/gebruikers/track/trackid/101/#.T5AbauxNs1Y). At the left you have somewher 'starten!!!!'. If you hit that he will move along the track but based on distance.
My goal is that I could move based on time. Final goal is that I have 2 markers, 2 tracks and that I could play it and see the difference between the 2 markers. If i use distance it will be for both the same, but I would see where person 1 (track 1) was and where person 2 was at that moment.
Anyone any idea how i could make this work? Or any idea how this is possible? One of my ideas is that I ask for every movement the position of a certain person (asking it to the database), but isn't that too heavy?
Currently I use v3, but if you think v2 is better for this, i could always switch ;)
Thanks!
I can only think of setInterval actually counting time ticks, as shown here
http://jsfiddle.net/KSp4j/
You mentioned querying a database, yet in your example all the points are in the source. What I show needs the data already loaded in the HTML file. I use a format:
[
[time 1st pt. arrived, lat, lng]
[time 2nd pt. arrived, lat, lng]
[time 3rd pt. arrived, lat, lng]
...
]
and check the elapsed time with array's time.
Recently I've been planning out how I would run a game with an environment/map that is capable of unlimited dimensions (unlimited being a loose terms as there's obviously limitations on how much data can be stored in memory, etc). I've achieved this using a "grid" that contains level data stored as a String that can be converted to a 2D Array that would represent objects and their properties.
Here's an example of two objects stored as a String:
"game.doodads.Tree#200#10#terrain$game.mobiles.Player#400#400#mobiles"
The "grid" is a 3D Array, of which the contents would represent the x/y coordinate of the grid cell. The grid cells would be, say, 600x600.
An example of this "grid" Array would be as follows:
var grid:Array = [[["leveldata: 0,0"],["leveldata 0,1"]],
[["leveldata: 1,0"],["leveldata 1,1"]]];
The environment will handle loading a grid square and it's 8 surrounding squares based on a given point. ie the position of the Player. It would have a function along the lines of
function loadCells(xp:int, yp:int):void
This would also handle the unloading of the previously loaded cells that are no longer close enough to be required. In the unload process, the data at grid[x][y] would be overwritten with the new data, which is created by looping through the objects in that cell and appending each new set of data to the grid cell data.
Everything works fine in terms of when you move in a direction, cells are unloaded/saved and new cells are loaded. The problem is this:
Say this is a large city infested by zombies. If you walk three grid squares in any direction and return, everything is as you left it. I'm struggling to find a way to at least simulate all objects still moving around and doing their thing. It looks silly when you for example throw a grenade, walk away, return and the grenade still hasn't detonated.
I've considered storing a timestamp on each object when I unload the level, and when it's initialized there's a loop that runs it's "step" function amount of times. Problem here is obviously that when you come back 5 minutes later, 20 zombies are going to try and step 248932489 times and the game will crash.
Ideas?
I don't know AS3 but let me try give you some tips.
It seems you want to make a seamless world since you load / unload cells as a player moves. That's a good idea. What you should do here is deciding what data a cell should load / unload( or, even further, what data a cell should hold or handle ).
For example, the grenade should not be unloaded by the cell as it needs to be updated even after the player leaves the cell. It's NOT a good idea for a cell to manage all game objects just because they are located in the cell. Instead, the player object could handle the grenade as an owner. Or, there could be one EntityManager which handles all game entities like grenades or zombies.
With this idea, you can update your 20 zombies even when they are in an unloaded zone (their location does not matter anymore) instead of calling update() 248932489 tiems at once. However, do you really need to keep updating the zombies? Perhaps, unloading all of them and spawning new zombies with the number of the latest active zombies in the cell would work. It depends on your game design but, usually, you don't have to update entities which are not visible or far enough from the player. Hope it helps. Good luck! :D
Interesting problem. Of course, game cannot simulate unlimited environment precisely. If you left some zone for a few minutes, you don't need every step of zombies (or any actors there) to be simulated precisely. Every game has its own simplications. Maybe approximate simulation will help you. For example, if survivor was in heavily infested zone for a long time, your simulator could decide that he turned into zombie, without computing every step of the process. Or, if horde was rampant in some part of the city, this part should be damaged randomly.
I see two methods as to how you could handle this issue.
first: you have the engine keep any active cells loaded, active means there are object-initiated events involving cell-owned objects OR player-owned objects (if you have made such a distinction that is). Each time such a cell is excluded from normal unloading behaviour it is assigned a number and if memory happens to run out the cells which have the lowest number will be unloaded. Clearly, this might be the hardest method code-wise but still it might be the only one truly doing what you desire.
second: use very tiny cells and let the engine keep a narrow path loaded. The cells migth then be 100x100 instead of 600x600 and 36 of them do the work one bigger cell would do ( risk: more cluttter code-wise) then each cell your player actually traverses ( not all that have been loaded to produce a natural visibility-range ) is kept in memory including every cell that has player-owned objects in it for a limited amount of time ( i.e. 5 minutes ).
I believe you can find out how to check for these conditions upon unloading yourself and hope to have been of help to you.