- 7 ore fa
Un nuovo videodiario degli sviluppatori per Star Citizen.
Categoria
🎮️
VideogiochiTrascrizione
00:00Scriviti al nostro canale
00:35Scriviti al nostro canale
01:18Scriviti al nostro canale
01:29Scriviti al nostro canale
01:31Scriviti al nostro canale
01:31Scriviti al nostro canale
01:32Scriviti al nostro canale
01:35Scriviti al nostro canale
01:36Scriviti al nostro canale
02:02Scriviti al nostro canale
02:06Scriviti al nostro canale
02:20Scriviti al nostro canale
02:21Scriviti al nostro canale
02:50Scriviti al nostro canale
02:51Scriviti al nostro canale
03:16Scriviti al nostro canale
03:23Nominatura
03:24Eーい
03:25Scriviti al nostro canale
03:33Asi
03:46Scriviti al nostro canale
03:50Editing.
03:51When creating a gameplay level, we build that level with a combination of assets and object
03:55containers.
03:56Originally, object containers had to be built in a dedicated object container level, which,
04:01unfortunately, made the contents of the object container only editable in the actual object
04:05container level.
04:06Confused yet?
04:07In other words, when designers are building levels with object containers, but want to
04:11modify the contents of that object container, the only way to do that is to exit the current
04:16level, open the object container level, do some tuning, save, export, and leave, then
04:21they'd have to move back into the level.
04:23What the team has done now allows the designer to edit the contents of an object container,
04:28save and export, all while inside the level.
04:30This creates a much better experience for our design team, and it's really going to save
04:35tons of time.
04:36Now, as a general approach in game development, we always try to make something once and make
04:41it perfect, but since reality never meets expectations, we are always looking for ways
04:45to reduce the time needed in what we call the discovery phase of a problem.
04:50One of the hardest parts about getting a code bug is finding out what is causing it and where
04:54it's located.
04:55So establishing tools and processes to reduce that time not only helps get to the speedy
04:59resolution, but also gets our talented programming team back to that feature we're all so excited
05:04to develop.
05:05So to that end, we've reworked the handling of vehicle internal damage states to significantly
05:10easier to set up now and debug.
05:12Interior damage states will be changed based on the cumulative health of a ship.
05:17Formally, it was written in flow graph, but now it has been integrated into the vehicle
05:20component so that it can be used in a variety of places.
05:24This new debug and set up process should do just that.
05:27Help us find the problem quickly, solve it fast, and get back to feature dev time.
05:31Now, on IFCS, we've now moved the entire intelligent flight control system of our ship's update
05:36process to batch update.
05:38Because IFCS is very isolated from the physics engine, taking in values like velocity, mass,
05:43center of mass, etc. and outputting one linear and one angular impulse, there's no reason
05:47IFCS needs to be updated in lockstep with the physics thread.
05:50This change will be much more efficient in eliminating a major bottleneck and hopefully
05:55allowing a larger number of simultaneous players on a server.
05:59We've talked about also making progress on this for a little bit now, and we've now
06:03completed the new Quantum Drive 2.0.
06:05We've removed the old code from the previous Quantum Drive system that controlled things
06:09like VFX and sound effects playback, as well as object obstruction detection and alignment
06:14code.
06:14We've also moved the targeting of a quantum point to the target selector on a ship, so
06:19that drive now only cares about the travel point itself.
06:21This reduces complexity of the drive code and should make it run smoother.
06:25We're doing some bug fixing, as well as some features that attach to the Quantum Drive,
06:28such as closing all external doors when doing a jump to help prevent accidents by jumping
06:33out of a ship traveling at high fractions in the speed of light.
06:36This should all result in a smoother working Quantum Drive that is ready for design and art to
06:40really start tweaking and implementing on all the ships.
06:42It's also ready for UI to start creating a much more realistic feel for how such an event
06:47should be handled in-game, as well as a few other features, like the star map.
06:52Now over on the LA ship front, the RSI Aurora has gone through a final art check this week.
06:56All that remains are any incoming bugs while going through design implementation, animation
07:01updating, sound effects, VFX, etc. with this ship.
07:04And we've also established up to 14 different skins for the designers to utilize as well.
07:09The Anvil Terrapin is finalizing its gray box phase, which means it's setting up the
07:13exterior hierarchy, polishing proxies, and baked and migrated animations.
07:17For the interior, we're currently polishing the geometry in the cockpit and the habitation,
07:22and now moving into final art.
07:23We've just handed the Terrapin over to TechDesign for their gray box setup on the ship as well.
07:54In this part, we've just made some silicon Pak james a project with the
07:57www.mesmerism.info
08:27www.mesmerism.info
09:01www.mesmerism.info
09:07www.mesmerism.info
09:10www.mesmerism.info
09:12www.mesmerism.info
09:18www.mesmerism.info
09:19www.mesmerism.info
09:20www.mesmerism.info
09:21www.mesmerism.info
09:22www.mesmerism.info
09:22www.mesmerism.info
09:23www.mesmerism.info
09:24www.mesmerism.info
09:25www.mesmerism.info
09:27In our worst case scenario, a scene could take up to 50 minutes to load into Maya due
09:30to the amount of characters and length of the scene, but with this improvement, the
09:34worst load time has been dramatically reduced by over 82%, meaning cinematics won't be
09:39waiting long to make quick iteration.
09:41And over on the skinning front, a female transfer mesh has been created, and the male transfer
09:45mesh has been massively updated.
09:47Now these transfer meshes are used in conjunction with all of our skinning tools to automate
09:51basic skinning of all of our new characters.
09:53Tech animators can now spend time perfecting the weighting of a mesh, allowing for a higher
09:58quality and a more accurate deformation in less time.
10:10On many of our heads, we've run into an issue where the eyelids had some vertex normal issues,
10:15which led to eyes looking pretty odd.
10:17Our tech art team has now identified the issue, and because the vertices of the eyelids were
10:21so close together, the normal would get flipped, but only on a few verts.
10:25So this has now been fixed, and characters can now sleep with ease.
10:29And speaking of characters, the team here has been knocking out countless costumes for Squadron
10:3342 and Star Citizen.
10:35Currently in production, another female character is finishing up her in-game asset, and then
10:39will be sent over to texturing and rigging, along with our OMC undersuits that have all
10:44finished up in-game modeling, and they're heading on over to texturing.
10:46The team also has several other Levski-specific characters, the Civilians and the Miners, which
10:52are currently being textured, then will head over to rigging and implementation into their
10:55final resting place in-game on the great planet of Delamar.
10:59And now in other exciting news, now that we're in a modular armor system, we're reworking
11:04some of our legacy UEE and pirate armors to bring them up to the quality of our current
11:08assets.
11:08This will allow them to be swappable with all those assets.
11:11We've officially started high poly on some of your favorites, then we'll be moving on
11:15to the in-game modeling and texturing pass rework.
11:18And speaking of customization, along with the new eye options, we'll have a multitude
11:23of styles of hair coming in the upcoming releases, starting with a select group for 3.0.
11:27These are in various states of production and heading toward the final finish line.
11:31We'll have a select group ready for the initial release, and we can't wait to cover up those
11:35hairless heads.
11:36And finally, we have more finished rigged and implement characters, starting with the male marine
11:40BDU, which will make its appearance in several places, including the Bridge of the Idris.
11:44The male deck crew can now safely EVA outside the ship in the vacuum of space when doing
11:49his work.
11:50And lastly, the female light armor has finished up her implementation pass, along with the
11:55female explorer flight suit, which will support her in the far reaches of the galaxy.
12:10Well, that's about it, and wraps us up here in Los Angeles.
12:13As always, thank you for allowing us to create this game we've always dreamed about, and we
12:17look forward to giving you more updates in the near future.
12:20Have a fantastic rest of the week, and we'll see you back in Los Angeles in no time.
12:25So it'll be nice to see people hauling something other than Big Benny's vending machines and unsuspecting
12:29NPCs.
12:31As great as all those videos were, the team has worked hard to give you a proper mechanic for
12:35the 3.0 release.
12:36Yeah, and cargo is just one of the many important features we're currently working on.
12:40A lot of them, like cargo and, say, derelict ships, will be easy to see, while others,
12:44like serialized variables, aren't as visible but are just as critical to the game.
12:47Yeah, no, they're absolutely definitely as critical to the game, because when you're
12:51attempting to build a game as large and complex as Star Citizen, it's essential to come up
12:54with a new way to streamline the data being transferred between the server and the client.
12:58And so here to explain exactly how serialized variables will improve our networking capabilities,
13:02and, of course, most importantly, your Star Citizen experience, let's hear from Lead Network
13:07programmer, Clive Johnson.
13:14My name's Clive Johnson.
13:16I work for Foundry 42 UK, where I'm the Lead Network programmer, working on Star Citizen.
13:21Today we're going to talk a little bit about serialized variables.
13:24So what are serialized variables?
13:27Well, they're not really something that you can see in the game, and ideally, if everything
13:32is working the way it should, then they're not something that you'd really ever need to
13:37think about.
13:37But they are the answer to a question, which I think is quite important, and that's how
13:43do you network a game like Star Citizen?
13:46One of the first times I asked myself that question was shortly after I joined the company, and I
13:51think my first reaction was one of sheer terror, you know, tears, panic, and once it kind of calmed
13:59down and the tears had stopped.
14:00You do what any engineer is going to do when faced with an impossible problem.
14:04You try and break it down into smaller impossible problems.
14:08When trying to answer the question, how we network Star Citizen, one of the first things we've
14:13got to think about is exactly who's going to do the work, who's going to network everything
14:17we have in the game.
14:18Now, Star Citizen itself is made up of thousands of different elements.
14:22elements, and some of these are visible, like planets, and ships, and players, and coffee
14:29cups, and others you don't see, like missions or the logic assigning out landing pads.
14:35Each of these elements is really a different type of entity, and each type might be used
14:41thousands of times throughout the game.
14:42But all the types behave in specific ways or have certain uses, and that has to be implemented
14:48in the code.
14:48And most of them need to work in both single-player, Squadron 42, and multiplayer, the Star Citizen.
14:56In other words, most of them have to be networked.
14:59So who's going to do the work?
15:01Well, currently we've got about 60 engineers coding different parts of the game, but we have
15:07only six network programmers.
15:09Half of these work in Austin on back-end services, and that includes, you know, our core online services
15:15such as matchmaking, and friends, and player authentication.
15:20The other half is my team here in the UK, and we focus mainly on the networking between
15:26the client and the server.
15:27So it's kind of up to us to make sure that all the entity types are correctly networked
15:33and everything's functioning the way we'd like it to in the multiplayer game.
15:37But with 60 programmers, or thereabouts, writing new code and making new entity types, if we've
15:41only got three actually making it work in multiplayer, my team needs to work about 20 times faster
15:48than anybody else.
15:49You know, we're good, but we're not that good.
15:51So clearly leaving all the networking to the network programmers is not going to work.
15:56So what we need to do is have every engineer make sure that their own code works in multiplayer.
16:03Well, the problem with that is that network programming is really very hard.
16:07And it can take years to learn all the different ins and outs.
16:11So we need a way to simplify it so that, you know, non-specialists can learn everything they
16:16need to do in just like a couple of hours.
16:19What we need is an API, which stands for an application programmer interface.
16:23And that's really a cushion between a programmer doing the work and the problem that they want
16:27to solve.
16:27The API kind of simplifies things by allowing the programmer to say exactly what it is that
16:32they want to do, but without saying how it should be done.
16:35So you can kind of think of it like driving a car.
16:38So obviously you've got your steering wheel and the pedals and, you know, other controls
16:42and gear stick, whatever.
16:43That's not how the car drives.
16:45They are just the controls that tell the car what to do.
16:48So under the hood, the driver's commands are turned into, you know, different settings
16:51for like fuel air mixture or engine timing or hydraulic pressures for brakes and power steering.
16:57And that's kind of the interface part of an application programmer interface.
17:01By building the right set of controls, you can change how the API actually works without
17:07having to change the code.
17:08So what about driver error?
17:10Cars equipped with assisted driving can take action when a driver makes a mistake and possibly
17:15prevent a crash.
17:16And we want the same sort of thing from the API that we're going to develop.
17:19When a programmer is using it, it actively prevents them from making mistakes that might
17:23cause us bugs or negatively impact performance.
17:26But we can go a bit further though.
17:29So currently the technology for driverless cars is being developed.
17:33When that happens, the skill needed to operate a driverless car drops to just saying where
17:38you want it to go.
17:38And this is what we're trying to do with our network API.
17:41Serialized variables are a really big part of that.
17:44By giving our programmers a simpler model to work with, they can quickly and safely network
17:51the game elements that they're working on.
17:53Meanwhile, those network programmers are freed up to try and ensure that the API not only
17:59works quickly and efficiently, but also it deals with all the problems that you can get
18:04while networking anything.
18:06So before we go any further, we probably need to talk about another question.
18:10And that's how do online multiplayer games actually work?
18:13If you were to see the game as programmers off and look at it, you'd see that everything
18:18is essentially lots of tables and values.
18:21Every entity in the game has its own table and each value corresponds to a different property
18:27of a entity.
18:28Because we need to know what each value is for, we've got to give them all names.
18:32So a table has two columns.
18:34Names on the left hand side and values on the right.
18:37A row in a table is what we call a variable.
18:41And that's mainly because its value can change over time.
18:43A ship might have variables for shield strength and how much fuel it's got left.
18:49Players can have variables to say whether they're running or walking.
18:52Most, but not all, of these variables will have an entity called a position.
18:58And that's going to tell us exactly where they are in the game's universe.
19:02And even though we kind of need three values for coordinates in 3D space,
19:05we tend to think of position as a single variable because one part changes,
19:10the other parts tend to change.
19:11So when an entity moves, it does so because the position variable has been changed,
19:16that that variable's not really just keeping track of where the entity is,
19:21it is actually saying where the entity is.
19:22Programmers can write code that looks at the values in a table that belongs to an entity
19:27and we can use those values to calculate some changes to other variables.
19:31And some of those variables might be in the same table
19:33or some might be in other tables belonging to different entities.
19:36So as the game progresses, these variables are modified according to,
19:39you know, the actions of players and AI.
19:42And these changes update the graphics that you see on screen
19:45and they can trigger particle effects and sound effects.
19:48To make this work in multiplayer, we've got to take one machine, the server,
19:54and have that make the changes to the tables.
19:57And then the server then needs to copy the modified tables to all the other machines,
20:02all the clients.
20:03And it does this by sending messages over the network, a bit like a group text message.
20:07And if everything works correctly, the clients and the server all have the same data in the tables
20:13and everyone's in sync.
20:14Now, entities in our game can have dozens or even hundreds of these variables or properties
20:19and most of them need to be kept in sync over the network.
20:23There are a few ways we could do this.
20:25And probably the most straightforward way is every now and then just to send the state of all the tables.
20:32And that works really well for very small numbers of entities.
20:35But as the number of entities increases, then the bandwidth that you're using to do that increases.
20:41And if we're not careful, that can cause us other problems.
20:44You might notice that most entities in the game don't tend to do much until someone does something to them.
20:50So what we can try is not sending the table for an entity unless it has changed.
20:56But now, the game code's got to keep track of which entities have changed and which haven't.
21:01And that can be tricky to get right.
21:02It's a manual process that the gameplay programs have to do.
21:05Getting it wrong means that in certain situations, the tables for particular entities
21:10will no longer be in sync. We call that a desync.
21:13And the effects of that can range from minor bugs that are just little annoyances
21:18to completely breaking the game.
21:20And the only way to find these bugs is through lots and lots of time-consuming playtesting.
21:25Perhaps worse, we haven't really solved the bandwidth problem either.
21:29By adding more players, that means that more entities will be being interacted with
21:34and having things done to them.
21:35So more tables are going to be getting updated.
21:37And more messages need to be sent out over the network.
21:40And the bandwidth jumps up once again.
21:41We still need to reduce this.
21:42So we might notice that when an entity's table is modified,
21:46not all the values in it are changed.
21:48So instead of sending the whole table,
21:50we could try just sending a few of them at a time.
21:52So we can split the table into sections.
21:55And then we're saving bandwidth by only sending a section
21:58if one or more of the variables in it have changed.
22:01If we put variables that are likely to change together in the same section,
22:06then we can save even more.
22:08But now the game code's got to keep track of not just modifications to entities,
22:11but modifications to individual sections.
22:14And that's even harder to get right.
22:16We're also going to write some extra code to say which variables need to be put into which messages.
22:20And since different types of entities have different sets of variables,
22:24they also need different sections.
22:26So this extra work has to be duplicated for every different type of entity.
22:30So the thing that really kills this plan for Star Citizen is entity components.
22:36A component is really, it's just a piece of code and some variables
22:39that implement a very specific piece of functionality.
22:44So entities get built by plugging different components together
22:47and by choosing different components that you want to plug together,
22:50that gives us different types of entities.
22:52If you need an entity that can move around and collide with other things,
22:56then you have to give it a physics component.
22:58If your entity needs shields, give it a shield component.
23:01The number of different entity types we can build this way
23:04grows exponentially with the number of different components that we have.
23:08But what also grows exponentially is the amount of networking work
23:14we've got to do to cover all these different entity types.
23:17So clearly this isn't really going to work for us.
23:20Our networking API needs to be smarter.
23:22What we wanted were controls that were as simple as those for a driverless car
23:26and what we had felt like it was as complicated as piloting a space shuttle.
23:30So that's when we came up with serialized variables.
23:33So with these, gameplay programmers just need to write their code
23:36the way they normally would.
23:38They're adding variables to their components as they need them.
23:41and the only extra thing that they need to do is mark the variables that they want networked
23:46in a special way.
23:48And that just shows that these ones are ones that need to be serialized.
23:52Serialization is a process of packing up the data in a form that's more efficient
23:55and better suits being sent over the network or serialized to a file.
23:59This makes life so much easier for our programmers.
24:01You can see how the code on the left can be simplified and reduced to what's on the right.
24:05It's really just like writing normal code
24:07and calling out which of the variables we want serialized.
24:10The programmer only needs to write the additional lines
24:12that you can see highlighted in purple on the right
24:14and add them to their struct or class definition.
24:17And that tells the serialized variable system
24:19which members of the structure to watch and update.
24:21Previously, we would have needed specific functions in each class.
24:25One for net serialized for networking,
24:28full serialized for the saved game.
24:30And if we wanted to talk to the persistent database
24:32we would have needed an extra function
24:33something like persistent serialized.
24:35In these functions, the game programmers would have had to manually
24:38look at the variables they wanted to serialize
24:40and write them out into the serialization stream.
24:43So there's lots of scope there for extra work
24:44and possible errors if they forget to add a variable.
24:47But now, when a programmer writes a new class
24:49they can just mark up which of the variables they want
24:51to be serialized.
24:52And everything else is handled automatically
24:54and efficiently behind the scenes.
24:56And that all goes through one unified system
24:58that we can profile and optimize
24:59as opposed to having to worry about
25:01optimizing literally thousands of different functions.
25:04Once the variables have been marked
25:05there's no need to group things into sections anymore.
25:09There's no extra code to write.
25:10The API detects when something has modified the value of a variable
25:15and it lets the netcode know so that I can deal with it.
25:17New API even writes the code to handle the serialization for them.
25:23And this kind of level of automation not only saves us time
25:26but it eliminates human error, meaning we have a lot fewer bugs
25:31and we can just get on more quickly and more efficiently.
25:34So because the netcode's now being told about changes to individual variables
25:38we're on the networking side of a much clearer view of what's actually happening in the game.
25:44So you can kind of think of it like switching to a 4K TV
25:47when all you've ever seen before is like green, black and white.
25:50And we're kind of using this extra information at the moment
25:53so that we only send exactly what has changed.
25:56And that means that our bandwidth pair update message,
25:59the size of our update messages is now probably about as optimized as it's possible to get.
26:05We're also using this information so that we can profile what's being sent by the game code
26:11when it's marking variables dirty so we can see if anyone's hitting anything particularly quickly
26:17and maybe there's a bug in the game code that he's looking at.
26:20Really the only kind of other improvements that we're going to get from now on
26:24are by optimizing streams of network messages,
26:28cutting out who's sending messages at all and how often messages are being sent.
26:34and we can handle all that on the network side, on the netcode side.
26:37So it's kind of like I was saying before where we've got this interface of the API
26:40that separates game code from what we need to do
26:43and we can make our changes without affecting them.
26:45While we were working on this new technology,
26:47we noticed that one of the entity types started sending about 80% less data.
26:53At first we just didn't believe that.
26:55We were certain that the numbers have got to be wrong or that a bug's throwing away most of the
27:00data.
27:00It wasn't until we went back and we double-checked everything
27:04that really we started to realize that this saving is actually real
27:08and that it's due to the new code.
27:10That's probably not going to be typical
27:12but it still kind of shows that the difference this kind of approach can make.
27:17That's not entirely where the story ends though
27:19because one of the other cool things about serialized variables
27:21is that they don't just work for multiplayer and networking.
27:24Instead of sending the different tables and values and variables between just server and clients,
27:30we can also store them in a database or save them to a file.
27:34And that means that for no extra effort at all,
27:38the gameplay programmers can use the same serialized variables for persistence,
27:42recording what the state of entities are in our persistent universe.
27:46And we can even use them for save games in Squadron 42.
27:49Personally, I think probably the best thing about serialized variables
27:53is that they're one of the cornerstones that we're using to build this big, seamless, persistent universe.
28:00Achieving that is going to require spreading the load over multiple servers.
28:05Because it's seamless, we're going to have to have these servers communicate with each other
28:09and that's going to mean that there could be a lot of servers aware of any particular entity.
28:14So let's say, for example, an AI pirate.
28:17Now we don't want all the servers trying to tell the pirate what he should be doing
28:22because first that would be just a complete waste of computing power.
28:25And the second reason is that the servers might not agree on what the AI should do next.
28:30So we need one server that's in charge of the AI pirate
28:34and only that server can send updates for that AI pirate entity
28:39and the other servers just listen to it.
28:41So the trick is going to be how we decide which server gets the final say.
28:46And we're going to do that with something that we're calling tokens.
28:49A token can only be held by one computer at a time.
28:52And when a computer is finished with a token, it just passes it on to the next one that wants
28:56it.
28:57By linking serialized variables and tokens together, we'll be able to transfer authority from one server to another as quickly
29:04as flicking a switch.
29:04What that means for our AI pirate is that control over its AI mind can pass seamlessly from one server
29:13to another.
29:13And since different servers, at least initially, will control different regions of space,
29:18this combination of tokens and serialized variables will allow our AI pirate and everything else
29:23to move freely to this seamless, persistent universe that's being simulated by lots of servers all working together.
29:31So hopefully you'll agree that serialized variables are not only a key part of the current technology,
29:38but they're a building block for future ones.
29:41And that's really not bad for something that you're never going to see.
29:44But that's often the reality of game development.
29:47And what you see in games really just the tip of an iceberg that's being buoyed up by a mass
29:52of systems and technologies
29:53all working together, you know, out of sight and fingers crossed out of mind.
30:00So as you can see, the serialized variable tech is an important feature for several reasons.
30:04It not only improves the game's networking, but also simplifies the coding for our programmers.
30:08so there'll be fewer bugs going forward.
30:10And the same data can be serialized over the network to the persistent database or save the state of the
30:16game,
30:16meaning we have one unified way to communicate or save game state throughout everything,
30:21which is very important for a big, huge universe like we're building.
30:26Absolutely.
30:27Anyway, that's it for today's program.
30:29But before we go, we wanted to remind all backers to keep your account safe by enabling two-step authentication.
30:35You can do that by visiting your account page, then clicking on the security tab under settings.
30:40Yeah, it's probably a good idea to do that.
30:42And thanks to all our subscribers.
30:44Your continued support makes ATV, BugSmashes and all our programs possible.
30:47And don't forget to tune in tomorrow for another one of our subscriber-supported shows.
30:52Happy Hour Friday.
30:53This week, Ben Lesnik will be playing Wing Commander 3 and discussing the history behind the game and its development.
30:58And in Man and Chris's case, that's a long time ago.
31:02I think 24 years ago we were developing it.
31:06So anyway, time flies.
31:09Finally, I'd like to thank all our backers.
31:11Your support and enthusiasm for the game has made all this possible.
31:14We couldn't do it without you.
31:15So until next week, we'll see you...
31:18Around the Verse.
31:54We'll see you next time.
Commenti