Hello!

It looks like you’re new here. To join in the discussion, click the register link below to get started.

Badges

First Anniversary10 CommentsName DropperFirst Comment
Welcome to the brand new Codemasters Forums! Be sure to check the FAQ and Forum Rules before you get started.

cjorgens79 New Car Smell

About

Username
cjorgens79
Joined
Visits
31
Last Active
Roles
Member
Points
36
Badges
4
  • Re: RS Dash telemetry companion app for F1 2016 & F1 2017

    JuanCarMR said:
    @cjorgens79 for those who bought F1 2016 app and was so poor (not for your work, I know), it should be great if you give us the F1 2017 app for free. 
    The F1 2016 telemetry was very limited in comparison to the new telemetry in F1 2017, hence why the F1 2016 interface is RS Dash had a lot less features. This was all clearly documented on the website in the spreadsheet which showed the functionality available in each interface. 

    It takes A LOT of time to make these interfaces and then to provide ongoing support to answer peoples questions when they have issues with their devices or routers or questions about why the telemetry doesn't provide this or that. Not to mention the ongoing costs i have to incur just to make these apps available, so that is why the app interfaces are charged and why that will not change.
  • Re: D-Box and UDP Telemetry Information

    @Hoo - in terms of the api, the following information (in no particular order) is missing compared to other sim racing interfaces ive linked with
    1. Tyre Temperature (everyone else has this, this is the most glaringly obvious missing field)
    2. Tyre Compound (R3E and AC have this, pCars and F1 2016 do not)
    3. Tyre Wear (pCars and AC have this)
    4. Brake bias (R3E has this, very useful to have available in app)
    5. Damage (the others all support this to some degree)
    6. Fuel Pressure, Water Pressure, Oil pressure (some have this as they simulate this)
    7. Water Temp, Oil Temp (some have this as they simulate this)
    8. Invalid lap (ie off track) indicator (very important for any app tracking lap times)
    9. AI player x/y/z positions (needed for displaying maps with position of all players)
    10. AI player race positions (1st, 2nd, 3rd etc) and lap times (needed for leaderboard and live streaming coverage)

    The UDP packet structure itself  could really use a revision number and packet size at the front so that interfaces can detect any changes to the api that may occur in future updates. A sequence number could also be helpful as UDP packet order arrival is not guaranteed.

    If the developers are going to add some of these things, they must take into account the MTU size to prevent UDP packet fragmentation from occuring, so the packet should not exceed 1500 bytes. The packet size at the moment (from memory) was about 280 bytes, so no problems, however if they add the telemetry from the other competitors then this grows quickly so needs to be considered carefully. F1 2016 has an advantage over the other games though in that the grid size is fixed to 22 cars and the AI opponents names are all known so can be encoded as an enum to save space. Ideally it would be great to have an array of an aiData structure something like the following added 
    {
    byte m_player_id                   // id of player, eg 0 = player, 1 = hamilton, 2 = rosberg, etc
    byte m_car_position             // race position of player, 1st, 2nd, 3rd, etc
    byte m_lap_invalid               // is current lap time is invalid (ie off track)
    byte m_sector                         // current sector player is in on this lap
    byte m_lap                              // current lap number player is on
    byte m_in_pits                       // is player in the pits?
    float m_lap_distance            // lap distance travelled
    float m_x                                 // world space position
    float m_y                                 // world space position
    float m_z                                 // world space position
    float m_lap_time                   // current lap time
    float m_last_lap_time          // last lap time
    float m_best_lap_time         // session best lap time (needed for qualifying leaderboards when app is started midway through session)
    float m_sector1_time           // current sector 1 time
    float m_sector2_time           // current sector 2 time
    }
    Structure packing would need to be considered so some of those byte fields could be combined into a single byte as the values wouldnt use all the available bits. eg m_lap_invalidated and m_in_pits only need 1 bit each. m_lap_distance could probably be reduced to 16 bit too if needed. 

    You could also technically drop the two sector times and the last lap time fields if  packet space was needed and instead just have a last sector time as the apps could still calculate what they need using just that. 

    Using my bloated example AI structure above for 22 opponents plus adding the other fields at the top of my list would result in a packet size of approx 1184 bytes, still reasonably well under the 1500 byte limit.

    The above is pretty much everything that i have available to me currently in my pCars Dash app from the Project Cars telemetry stream and it has proven to be very popular among the players, providing them with another dimension to the racing which has kept them engaged in the game longer. Hopefully you will consider adding the above to the api as companions apps do help the game retain its players for longer.

    Thanks
    Craig
    Pocket Playground
    www.pocketplayground.net
    Home of pCars Dash for Project CARS and RS-Dash for F1 2016, RaceRoom Racing Experience and Assetto Corsa.