I know how to program although I haven't done much in C# yet. But I understand every code snippet I read. I mostly script at my job. I have little to no experience in graphical design or animations.
The only thing I have done so far in Unity 3D is the ball rolling tutorial.
I have some questions though as I have a hard time understanding where I should begin. I know co-op 3D RPG is a project with a HUGE scope, but this is what I would like to accomplish to begin with:
Mini world (half the size of a WoW zone)
Populate world with terrain, trees and some buildings. Maybe a cave.
Have a playable character that can move around and interact with some objects.
Could anyone guide me into the right direction? What documentation should I read? Are there any RPG packs or plugins that can help me achieve this? Any nice tutorials you know of?
If 3D is too complicated to start with, I'm also willing to try an isometric game.
PS: Are there any free (or reasonably priced) HD asset packs that include animations? Or will I have to provide those myself as well?
Co-Op RPG's are quite large; Infact most people have tools that would help this speed up production; Although you're asking where to start. Most of my programming knowledge comes from theory and pretty basic knowledge; But I have an idea on where you should start!
A big factor on Co-Op is well.... Of-course CO-OP so something you should play around with first is data and how it's stored but even though you have knowledge of this factor Unity has a good way of storing it from Host to Client!
https://docs.unity3d.com/Manual/UNetStateSync.html?_ga=2.98238303.1333003911.1509902124-1740889112.1506544791
Another factor of -Co-Op is the dynamic spawning that is going to be pretty heavy although their are quite a few ways of doing this I'm sure their are plenty of correct as-well as incorrect ways of doing it!
Personally I would develop a database and call-Events with SQLite though this would be a heavy and complex job to do correctly and efficiently
but unity3d has UNetCustomSpawning documentation that seems to work pretty well for it's inteded use although it takes some heavy tinkering to get right so I would suggest once you get synchronization done you should check out some Spawning
https://docs.unity3d.com/Manual/UNetCustomSpawning.html
With Every Co-Op Action it must be handled and heres how!
https://docs.unity3d.com/Manual/UNetActions.html
How about the actual connection?
https://docs.unity3d.com/Manual/UNetDiscovery.html
Although reading alot of this may help; I would suggest rading through this and giving it a shot.
https://docs.unity3d.com/Manual/UNetSetup.html
and if you find no help or it's doing you some trouble
https://unity3d.com/learn/tutorials/s/tanks-tutorial
You may hear about "Tanks", alot though I personally am quite stubborn so I couldn't bear to look into it untill I did just earlier this month; It shows a correct way of doing things from Shooting, to spawning, and may other things.
I am un-certain this is a good or bad answer for you as this I believe is quite a personal question but as their are about a thousand and a thousand more ways of doing this I think what I have shown is a great way of starting just to get an idea of how the ball should start rolling!
-Thanks!
I've been messing around with some coding and finally think I'm finally ready for the OpenGL part, then I thought again and decided that I need some guidance with how to learn/ remember OpenGL ES 2.0!
Alright, basically, I know how it works in the high level, then when I begin to type out some code....
I see a bunch of parameters,
I refer to some documents,
I fill in those parameters,
I see some more parameters,
I refer to more documents,
(loop)
MVC comes in,
I get completely and utterly confused!
Brain crashes.
I'm trying to do some simple stuff on the iPhone, I'd like to find the train of thoughts of the gurus, like some sort of check list, or order to do things, so that what I'm doing will always be clear!
Eg, something like:
Arrays of numbers always come before shaders
(some sets of program lines that always appear in a certain order)
Right now, I have a high level understanding of something like this:
http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Chapter-1%3a-The-Graphics-Pipeline.html
What I wish I could know is what are the usual steps involve, if you were to expand all these high level understanding like tags in a website!
I tried reading some tutorials, and I'll be trying again after typing this, to attempt to absorb the common steps/ order to do this, if anyone can help speed up the process, I'll be veeeeeery very grateful! Am I asking too much? =p
I highly recommend this tutorial book for GL on the iPhone
It's particularly useful for fairly experienced developers who are starting with GL. If you are starting at a more beginner level, it may be confusing in parts.
I was wondering if anyone knew of a simple way to implement graphing in an iPhone/iPad application. I've spent quite a bit of time googling and can't seem to find any sort of a solution. Maybe I'm just searching with the wrong terms since a lot of consumers are asking about "graphing" in terms of using their applications, not developing them, the search-space is rather polluted.
It seems like a lot of iPad/iPhone applications have embedded graphs... and I can't imagine that every developer has invented their own graphing engine from the ground up. Or, maybe they have... Does anyone have any suggestions?
Core Plot is one popular option.
I have herd wonders about core plot but for myself i wrote a graph View Class which creates a standard graph.
Have a look
http://sebkade.wordpress.com/2010/05/06/basic-graph-class-for-iphone/
hope it helps
From my experience graphs are best done through UIWebView's and then written in HTML/JavaScript - there are many great html/javascript libraries for graphings. Personally, I like
http://www.highcharts.com
but these exist as well.
http://www.sencha.com/products/touch/charts
https://developers.google.com/chart/
http://www.zingchart.com/#welcome
I have a small UIImage (jpg) with a single typed number. I want to be able to read the number with some kind of pattern recognition. I'm really not sure where to start, so any help would be appreciated.
my initial idea was to compare this image with other images. For instance compare the image with that of a 1,2,3, etc until a match was found. That just seems slow and cumbersome and wondered if there was a better way to do it?
Thanks
Update - I'm trying to convert sudoku puzzles from newspaper print to interactive puzzles
No, you are right, it will be slow and cumbersome. But on the plus side you don't have to write it yourself
http://sourceforge.net/projects/opencvlibrary/
Still not exactly easy tho, and i'm not sure about licensing, so… you don't mention why you need to do this (sounds a little odd).
Maybe you can avoid it? If you know the images are numerical digits 0-9, is there another way to track which one a particalur images is, apart from the way it's pixels are arranged?
Sorry if that sounds like i'm missing the point… Maybe you could fill in a few more details?
I read this really good write-up about this exact problem here: http://sudokugrab.blogspot.com/2009/07/how-does-it-all-work.html
It doesn't have any code samples, but explains the concepts, and might be able to point you in the right direction.
The following tutorial may be right down your alley:
http://blog.damiles.com/2008/11/basic-ocr-in-opencv/
It is a simple tutorial on doing number recognition and comes with the source code also.
Additionally, you may want to do a search on OCR SDK (Optical Character Recognition Software Development Kit). You will surely find a stack of them. Commercial ones a pricey though.
I would go for a "role your own" approach along the line of the OpenCV tutorial, especially since you are only interested in numbers.
All of the best ':-)
I'm occasionally unfortunate enough to have to make alterations to very old, poorly not documented and poorly not designed code.
It often takes a long time to make a simple change because there is not much structure to the existing code and I really have to read a lot of code before I have a feel for where things would be.
What I think would help a lot in cases like this is a tool that would allow one to visualise an overview of the code, and then maybe even drill down for more detail. I suspect such a tool would be very hard to get right, given that is trying to find structure where there is little or none.
I guess this is not really a question, but rather a musing. I should make it into a question - What do others do to assist in getting their head around other peoples code, the good and the bad?
Hmm, this is a hard one, so much to say so little time ...
1) If you can run the code it makes life soooo much easier, breakpoints (especially conditional) break points are you friend.
2) A purists' approach would be to write a few unit tests, for known functionality, then refactor to improve code and understanding, then re-test. If things break, then create more unit tests - repeat until bored/old/moved to new project
3) ReSharper is good at showing where things are being used, what's calling a method for instance, it's static but a good start, and it helps with refactoring.
4) Many .net events are coded as public, and events can be a pain to debug at the best of times. Recode them to be private and use a property with add/remove. You can then use break point to see what is listening on an event.
BTW - I'm playing in the .Net space, and would love a tool to help do this kind of stuff, like Joel does anyone out there know of a good dynamic code reviewing tool?
I have been asked to take ownership of some NASTY code in the past - both work and "play".
Most of the amateurs I took over code for had just sort of evolved the code to do what they needed over several iterations. It was always a giant incestuous mess of library A calling B, calling back into A, calling C, calling B, etc. A lot of the time they'd use threads and not a critical section was to be seen.
I found the best/only way to get a handle on the code was start at the OS entry point [main()] and build my own call stack diagram showing the call tree. You don't really need to build a full tree at the outset. Just trace through the section(s) you're working on at each stage and you'll get a good enough handle on things to be able to run with it.
To top it all off, use the biggest slice of dead tree you can find and a pen. Laying it all out in front of you so you don't have to jump back and forward on screens or pages makes life so much simpler.
EDIT: There's a lot of talk about coding standards... they will just make poor code look consistent with good code (and usually be harder to spot). Coding standards don't always make maintaining code easier.
I do this on a regular basis. And have developed some tools and tricks.
Try to get a general overview (object diagram or other).
Document your findings.
Test your assumptions (especially for vague code).
The problem with this is that on most companies you are appreciated by result. That's why some programmers write poor code fast and move on to a different project. So you are left with the garbage, and your boss compares your sluggish progress with the quick and dirtu guy. (Luckily my current employer is different).
I generally use UML sequence diagrams of various key ways that the component is used. I don't know of any tools that can generate them automatically, but many UML tools such as BoUML and EA Sparx can create classes/operations from source code which saves some typing.
The definitive text on this situation is Michael Feathers' Working Effectively with Legacy Code. As S. Lott says get some unit tests in to establish behaviour of the lagacy code. Once you have those in you can begin to refactor. There seems to be a sample chapter available on the Object Mentor website.
I strongly recommend BOUML. It's a free UML modelling tool, which:
is extremely fast (fastest UML tool ever created, check out benchmarks),
has rock solid C++ import support,
has great SVG export support, which is important, because viewing large graphs in vector format, which scales fast in e.g. Firefox, is very convenient (you can quickly switch between "birds eye" view and class detail view),
is full featured, intensively developed (look at development history, it's hard to believe that so fast progress is possible).
So: import your code into BOUML and view it there, or export to SVG and view it in Firefox.
See Unit Testing Legacy ASP.NET Webforms Applications for advice on getting a grip on legacy apps via unit testing.
There are many similar questions and answers. Here's the search https://stackoverflow.com/search?q=unit+test+legacy
The point is that getting your head around legacy is probably easiest if you are writing unit tests for that legacy.
I haven't had great luck with tools to automate the review of poorly documented/executed code, cause a confusing/badly designed program generally translates to a less than useful model. It's not exciting or immediately rewarding, but I've had the best results with picking a spot and following the program execution line by line, documenting and adding comments as I go, and refactoring where applicable.
a good IDE (EMACS or Eclipse) could help in many cases. Also on a UNIX-platform, there are some tools for crossreferencing (etags, ctags) or checking (lint) or gcc with many many warning options turned on.
First, before trying to comprehend a function/method, i would refactor it a bit to fit your coding conventions (spaces, braces, indentation) and remove most of the comments if they seem to be wrong.
Then I would refactor and comment the parts you understood, and try to find/grep those parts over the whole source tree and refactor them there also.
Over the time, you get a nicer code, you like to work with.
I personally do a lot of drawing of diagrams, and figuring out the bones of the structure.
The fad de jour (and possibly quite rightly) has got me writing unit tests to test my assertions, and build up a safety net for changes I make to the system.
Once I get to a point where I'm comfortable enought knowing what the system does, I'll take a stab at fixing bugs in the sanest way possible, and hope my safety nets neared completion.
That's just me, however. ;)
i have actuaally been using the refactoring features of ReSharper to help m get a handle on a bunch of projects that i inherited recently. So, to figure out another programmer's very poorly structured, undocumented code, i actually start by refactoring it.
Cleaning up the code, renaming methods, classes and namespaces properly, extracting methods are all structural changes that can shed light on what a piece of code is supposed to do. It might sound counterintuitive to refactor code that you don't "know" but trut me, ReSharper really allows you to do this. Take for example the issue of red herring dead code. You see a method in a class or perhaps a strangely named variable. You can start by trying to lookup usages or, ungh, do a text search, but ReSharper will actually detect dead code and color it gray. As soon as you open a file you see in gray and with scroll bar flags what would have in the past been confusing red herrings.
There are dozens of other tricks and probably a number of other tools that can do similar things but i am a ReSharper junky.
Cheers.
Get to know the software intimately from a user's point of view. A lot can be learnt about the underlying structure by studying and interacting with the user interface(s).
Printouts
Whiteboards
Lots of notepaper
Lots of Starbucks
Being able to scribble all over the poor thing is the most useful method for me. Usually I turn up a lot of "huh, that's funny..." while trying to make basic code structure diagrams that turns out to be more useful than the diagrams themselves in the end. Automated tools are probably more helpful than I give them credit for, but the value of finding those funny bits exceeds the value of rapidly generated diagrams for me.
For diagrams, I look for mostly where the data is going. Where does it come in, where does it end up, and what does it go through on the way. Generally what happens to the data seems to give a good impression of the overall layout, and some bones to come back to if I'm rewriting.
When I'm working on legacy code, I don't attempt to understand the entire system. That would result in complexity overload and subsequent brain explosion.
Rather, I take one single feature of the system and try to understand completely how it works, from end to end. I will generally debug into the code, starting from the point in the UI code where I can find the specific functionality (since this is usually the only thing I'll be able to find at first). Then I will perform some action in the GUI, and drill down in the code all the way down into the database and then back up. This usually results in a complete understanding of at least one feature of the system, and sometimes gives insight into other parts of the system as well.
Once I understand what functions are being called and what stored procedures, tables, and views are involved, I then do a search through the code to find out what other parts of the application rely on these same functions/procs. This is how I find out if a change I'm going to make will break anything else in the system.
It can also sometimes be useful to attempt to make diagrams of the database and/or code structure, but sometimes it's just so bad or so insanely complex that it's better to ignore the system as a whole and just focus on the part that you need to change.
My big problem is that I (currently) have very large systems to understand in a fairly short space of time (I pity contract developers on this point) and don't have a lot of experience doing this (having previously been fortunate enough to be the one designing from the ground up.)
One method I use is to try to understand the meaning of the naming of variables, methods, classes, etc. This is useful because it (hopefully increasingly) embeds a high-level view of a train of thought from an atomic level.
I say this because typically developers will name their elements (with what they believe are) meaningfully and providing insight into their intended function. This is flawed, admittedly, if the developer has a defective understanding of their program, the terminology or (often the case, imho) is trying to sound clever. How many developers have seen keywords or class names and only then looked up the term in the dictionary, for the first time?
It's all about the standards and coding rules your company is using.
if everyone codes in different style, then it's hard to maintain other programmer code and etc, if you decide what standard you'll use have some rules, everything will be fine :) Note: that you don't have to make a lot of rules, because people should have possibility to code in style they like, otherwise you can be very surprised.