પ્રથમ, તમારે એક ખેલાડીની જરૂર છે જે આ વિસ્તારની આસપાસ જોઈ શકે.
ઉદાહરણ તરીકે, તમે આ માટે ખાલી ઓબ્જેક્ટ બનાવી શકો છો. વંશવેલો વિંડોમાં ક્રિએટન -> જમણા માઉસ બટનથી ખાલી પસંદ કરો. પ્રથમ વ્યક્તિ ખેલાડી તરીકે પદાર્થને નામ આપો. તેને તમારા દ્રશ્યની મધ્યમાં ખેંચો. એક અક્ષર નિયંત્રક ઘટક ઉમેરો.
પાત્રને F સાથે કેન્દ્રમાં રાખો અને ખાતરી કરો કે ગીઝમોઝ સક્રિય છે. પછી પાત્રની મર્યાદાઓ સ્પષ્ટ થાય છે. આગળ, ઑબ્જેક્ટને જોવા માટે સરળ બનાવવા માટે ગ્રાફિક બનાવો. ગેમ ઑબ્જેક્ટ પર જમણું-ક્લિક કરો, બનાવો -> 3D->સિલિન્ડર પસંદ કરો. પછી કેપ્સ્યુલ દૂર કરો Collider, કારણ કે કેરેક્ટર કંટ્રોલર કોલાઈડર તરીકે કામ કરે છે. તમારા પાત્રને સામગ્રી સોંપવા માટે બનાવો–> સામગ્રી પસંદ કરો. સામગ્રીને પ્લેયર પર ખેંચો.
જો તમારી પાસે હજી સુધી રમતમાં કેમેરા નથી, તો તમે તેને GameObject પર જમણા માઉસ બટનથી બનાવી શકો છો અથવા તમે MainCamera ને તમારા GameObject પર ખેંચી શકો છો, જે ખેલાડી તરીકે કામ કરે છે.
કેમેરા પસંદ કરો, પરિવર્તન ઘટકને ફરીથી સેટ કરો અને તેને ખેલાડીના વડા વિસ્તારમાં ખેંચો. કેમેરા બધી રીતે ઉપર ન જવો જોઈએ, કારણ કે જ્યારે તમારું પાત્ર કૂદકે ત્યારે કેમેરા છત પરથી ન જવો જોઈએ.
તમારે એક સ્ક્રિપ્ટની જરૂર છે જે તમને આસપાસ જોવાની મંજૂરી આપે. બધું માઉસ સાથે ખસેડવામાં આવે છે અને તે બે અક્ષ (x અને y) પર ફરે છે. જો તમે માઉસને બાજુ પર ખસેડો છો, તો ખેલાડીને વાય-અક્ષ પર ફેરવવું જોઈએ. જો તમે માઉસને ઉપર અથવા નીચે ખસેડો છો, તો તમારું પાત્ર ખસેડવું જોઈએ નહીં, ફક્ત એક્સ-અક્ષ પરનો કેમેરો.
કેમેરાનું પરિભ્રમણ 180 to સુધી મર્યાદિત હોવું જોઈએ જેથી તે ખેલાડીની પાછળ ન જાય. આ પ્રક્રિયા ક્લેમ્પિંગ તરીકે ઓળખાય છે. કેમેરા પસંદ કરો અને નવો ઘટક ઉમેરો: માઉસ લુક
સ્ક્રિપ્ટના અપડેટ ફંક્શનમાં માઉસ મૂવમેન્ટ માટે ઇનપુટ ફંક્શન નાખવાનું છે.
બનાવો:
ફ્લોટ mouseX = Input.GetAxis ("માઉસ X")
આ માઉસ રોટેશન માટે યુનિટીમાં પ્રોગ્રામ એક્સેસ છે.
Y- અક્ષ માટે પણ આવું કરો:
float mouseY = Input.GetAxis ("Mouse Y");
હવે તમે માઉસ ની ઝડપ નિયંત્રિત કરવા માંગો છો.
તેથી જાહેર વર્ગ હેઠળ બનાવો:
જાહેર ફ્લોટ માઉસસંવેદનશીલતા = 100 એફ;
ઇનપુટ માઉસ સેન્સિટિવિટી દ્વારા ગુણાકાર કરવામાં આવે છે.
પ્રથમ વ્યક્તિના દ્રષ્ટિકોણથી રમત માટે સ્ક્રિપ્ટ લખો
પ્રથમ, તમારે એક ખેલાડીની જરૂર છે જે આ વિસ્તારની આસપાસ જોઈ શકે.
ઉદાહરણ તરીકે, તમે આ માટે ખાલી ઓબ્જેક્ટ બનાવી શકો છો. વંશવેલો વિંડોમાં ક્રિએટન -> જમણા માઉસ બટનથી ખાલી પસંદ કરો. પ્રથમ વ્યક્તિ ખેલાડી તરીકે પદાર્થને નામ આપો. તેને તમારા દ્રશ્યની મધ્યમાં ખેંચો. એક અક્ષર નિયંત્રક ઘટક ઉમેરો.
પાત્રને F સાથે કેન્દ્રિત કરો અને ખાતરી કરો કે ગીઝમો સક્રિય છે. પછી પાત્રની મર્યાદાઓ જોઈ શકાય છે. આગળ, ગ્રાફિક બનાવો જેથી objectબ્જેક્ટ વધુ સારી રીતે જોઈ શકાય. ગેમઓબ્જેક્ટ પર જમણું -ક્લિક કરો, બનાવો -> 3D–> સિલિન્ડર પસંદ કરો. પછી કેપ્સ્યુલ કોલાઇડરને દૂર કરો કારણ કે કેરેક્ટર કંટ્રોલર કોલાઇડર તરીકે કામ કરે છે. તમારા પાત્રને સામગ્રી સોંપવા માટે બનાવો-> સામગ્રી પસંદ કરો. સામગ્રીને ખેલાડી પર ખેંચો.
જો તમારી પાસે હજી સુધી રમતમાં કેમેરા નથી, તો તમે તેને GameObject પર જમણા માઉસ બટનથી બનાવી શકો છો અથવા તમે MainCamera ને તમારા GameObject પર ખેંચી શકો છો, જે ખેલાડી તરીકે કામ કરે છે.
કેમેરા પસંદ કરો, પરિવર્તન ઘટકને ફરીથી સેટ કરો અને તેને ખેલાડીના વડા વિસ્તારમાં ખેંચો. કેમેરા બધી રીતે ઉપર ન જવો જોઈએ, કારણ કે જ્યારે તમારું પાત્ર કૂદકે ત્યારે કેમેરા છત પરથી ન જવો જોઈએ.
તમારે એક સ્ક્રિપ્ટની જરૂર છે જે તમને આસપાસ જોવાની મંજૂરી આપે. બધું માઉસ સાથે ખસેડવામાં આવે છે અને તે બે અક્ષ (x અને y) પર ફરે છે. જો તમે માઉસને બાજુ પર ખસેડો છો, તો ખેલાડીને વાય-અક્ષ પર ફેરવવું જોઈએ. જો તમે માઉસને ઉપર અથવા નીચે ખસેડો છો, તો તમારું પાત્ર ખસેડવું જોઈએ નહીં, ફક્ત એક્સ-અક્ષ પરનો કેમેરો.
કેમેરાનું પરિભ્રમણ 180 to સુધી મર્યાદિત હોવું જોઈએ જેથી તે ખેલાડીની પાછળ ન જાય. આ પ્રક્રિયા ક્લેમ્પિંગ તરીકે ઓળખાય છે. કેમેરા પસંદ કરો અને નવો ઘટક ઉમેરો: માઉસ લુક
સ્ક્રિપ્ટના અપડેટ ફંક્શનમાં માઉસ મૂવમેન્ટ માટે ઇનપુટ ફંક્શન નાખવાનું છે.
બનાવો:
ફ્લોટ mouseX = Input.GetAxis ("માઉસ X")
આ માઉસ રોટેશન માટે યુનિટીમાં પ્રોગ્રામ એક્સેસ છે.
Y- અક્ષ માટે પણ આવું કરો:
float mouseY = Input.GetAxis ("Mouse Y");
હવે તમે માઉસ ની ઝડપ નિયંત્રિત કરવા માંગો છો.
તેથી જાહેર વર્ગ હેઠળ બનાવો:
જાહેર ફ્લોટ માઉસસંવેદનશીલતા = 100 એફ;
ઇનપુટ માઉસ સેન્સિટિવિટી દ્વારા ગુણાકાર કરવામાં આવે છે. વધુમાં, ચળવળ ફ્રેમ દરથી સ્વતંત્ર હોવી જોઈએ. વધુમાં તમારા કાર્યને Time.deltaTime દ્વારા ગુણાકાર કરો;
તમે Y- અક્ષ સાથે પણ આવું કરો. આ પરિભ્રમણની ઝડપને ફ્રેમ રેટમાં અપનાવે છે.
હવે ખેલાડીનું શરીર પણ હલવું જોઈએ. આ માટે મુખ્ય કેમેરાથી 1 લી વ્યક્તિ પદાર્થનો સંદર્ભ જરૂરી છે.
આ કરવા માટે, બનાવો: પબ્લિક ટ્રાન્સફોર્મ પ્લેયરબોડી;
અપડેટ એરિયામાં પ્લેયરબોડીને એક્સેસ કરો.
playerBody.Rotate (Vector3.up * mouseX)
પછી પ્લેયરને પ્લેયરબોડી વિસ્તારમાં ખેંચો.
હવે ઉપર -નીચે જોવાની વાત છે. આ કરવા માટે, માઉસને X અક્ષની આસપાસ ફરવું આવશ્યક છે.
આ માટે ખાનગી ચલ બનાવો:
ફ્લોટ xRotation = 0f
અપડેટ ક્ષેત્રમાં ઉમેરો:
xRotation - = mouseY;
હવે પરિભ્રમણ ઉમેરવામાં આવ્યું છે:
transform.localRotation = Quaternion.Euler ()
ચતુર્થાંશ એકતામાં એકતામાં પરિભ્રમણ માટે જવાબદાર છે. પછી x, y અને z મૂલ્યો છે.
transform.localRotation = Quaternion.Euler (xRotation, 0f, 0f);
આ પરિભ્રમણ માટે હવે "ક્લેમ્પિંગ" ઉમેરવું આવશ્યક છે.
આ માટે તમારે જરૂર છે:
xRotation = Mathf.Clamp (xRotation, -90f, 90f)
આ કેમેરાની હિલચાલ -90f અને 90f સુધી મર્યાદિત કરે છે. આ રીતે તમે ખાતરી કરી શકો છો કે કેમેરા ખેલાડીની પાછળ ઓવરરોટેટ થતો નથી.
સ્ટાર્ટ ફંક્શનમાં હજી એક કોડ ખૂટે છે, જે કર્સરને સ્ક્રીનની મધ્યમાં પ્રારંભિક બિંદુ તરીકે સેટ કરે છે.
Cursor.lockState = CursorLockMode.Locked;
સ્ક્રિપ્ટ હવે આની જેમ દેખાય છે:
આગળ ખેલાડીઓની હિલચાલ છે. ખેલાડીઓની હિલચાલ માટે ઇનપુટ્સ જરૂરી છે. આડા અને verticalભા અક્ષો માટે પ્રવેશો જરૂરી છે. ચળવળ કીઓ, જે એકતામાં પૂર્વવ્યાખ્યાયિત છે, કીબોર્ડ પર સ્થિત છે અને W, A, S અને D છે.
W માટે, વર્ટિકલ = 1
એસ -> વર્ટિકલ = -1
તે જ આડી માટે જાય છે:
A -> -1
ડી -> 1
આ સેટિંગ્સ નિયંત્રક માટે એક જ સમયે કામ કરે છે.
ખેલાડી x-અક્ષ સાથે બાજુમાં અને z-અક્ષ સાથે આગળ અને પાછળ ખસે છે.
ચળવળ હંમેશા તે દિશામાં સંબંધિત હોવી જોઈએ જેમાં ખેલાડી જોઈ રહ્યો હોય.
આ માટે આપણને પ્લેયર મોવમેન્ટ સ્ક્રિપ્ટની જરૂર છે જે વિઝ્યુઅલ સ્ટુડિયોમાં લખાયેલી છે. આને FirstPersonPlayer માં ઉમેરો.
રદબાતલ અપડેટ હેઠળ બનાવો:
float x = Input.GetAxis ("આડું");
float z = Input.GetAxis ("Vertical");
હવે ઇનપુટ તે દિશામાં રૂપાંતરિત થાય છે જેમાં ખેલાડીએ ખસેડવું જોઈએ.
Verctor3 ચાલ = transform.right * x + transform.forard * z;
તમે હવે ખેલાડી ચળવળ અને સંબંધિત x અને z ચળવળ પર આધારિત દિશા બનાવી છે. પરિણામે, પાત્ર હંમેશા જે દિશામાં જોઈ રહ્યો છે તેના આધારે આગળ વધે છે.
અક્ષર નિયંત્રકનો સંદર્ભ પણ જરૂરી છે.
હવે જાહેર તરીકે CharacterController બનાવો:
જાહેર કેરેક્ટર કંટ્રોલર નિયંત્રક;
પ્રારંભ સંદેશ દૂર કરો.
હવે વેક્ટર 3 ચાલ હેઠળ ઉમેરો:
નિયંત્રક. ખસેડો (ખસેડો);
આ ઉપરાંત, ચળવળની ગતિ નિયંત્રિત કરવામાં સક્ષમ હોવી જોઈએ:
જાહેર ફ્લોટ ઝડપ = 12 એફ;
તેથી નિયંત્રકની હિલચાલને ઝડપથી ગુણાકાર કરો:
નિયંત્રક. ખસેડો (ગતિ * ગતિ);
વધુમાં "* Time.deltaTime") છે;
કારણ કે તે અપડેટ એરિયામાં છે.
controller.Move (move * speed * Time.deltaTime);
આ ફ્રેમ રેટ સ્વતંત્ર બનાવે છે.
પછી CharacterController ખેંચવામાં આવે છે. જ્યારે કેમેરા ફરે છે, ખેલાડી જે દિશામાં આગળ વધે છે.
સીડી ચ climી શકવા માટે, ઉદાહરણ તરીકે, કેરેક્ટર કંટ્રોલરની સ્ટેપઓફસેટ વધારવી જરૂરી છે, દા.ત. B. થી 0.7
સ્ટેપ ઓફસેટ એ નક્કી કરે છે કે તમે કેટલા stepsંચા પગથિયા ચ climી શકો છો. Slાળ મર્યાદા હેઠળ તમે એ કોણ નક્કી કરો છો જે તમારું પાત્ર ચbી શકે છે.
આગળ, તમારે ગુરુત્વાકર્ષણની જરૂર છે જેથી તમારું પાત્ર હવામાં અટકી ન જાય જ્યારે, ઉદાહરણ તરીકે, તે સીડી ચડ્યો હોય.
ગુરુત્વાકર્ષણને એક બળ તરીકે વ્યાખ્યાયિત કરવામાં આવે છે જે ચોક્કસ સમયમાં કાર્ય કરે છે. જ્યારે તે અસરકારક હોય ત્યારે ઝડપ વધે છે. સ્પીડ વેરિયેબલ જરૂરી છે.
તમને જરૂર છે:
વેક્ટર 3 વેગ;
વાય-અક્ષના સંદર્ભમાં ઝડપ ગુરુત્વાકર્ષણ સ્થિરતા સાથે સુયોજિત છે.
velocity.y + =
પણ બનાવો: જાહેર ફ્લોટ ગુરુત્વાકર્ષણ = -9,81f;
પછી તમે ઝડપમાં ગુરુત્વાકર્ષણ ઉમેરો.
velocity.y + = ગુરુત્વાકર્ષણ * Time.deltaTime;
તમે ઉમેરો ઝડપ ઉમેરવા માટે:
controller.Move (વેગ * Time.deltaTime)
ડેલ્ટા વાય ગુરુત્વાકર્ષણના અડધા સમયના ગુણાકારથી પરિણમે છે.
આ કારણોસર ઝડપને ટાઇમ.ડેલ્ટાટાઇમ દ્વારા ફરીથી ગુણાકાર કરવામાં આવે છે.
સમાપ્ત સ્ક્રિપ્ટ આના જેવી દેખાય છે:
ગ્રેવીએશન હવે ખેલાડીને અસર કરે છે.
ખાલી Createબ્જેક્ટ બનાવો અને તેને તમારા પ્લેયર પર નીચે ખેંચો અને તેને ગ્રાઉન્ડચેક નામ આપો. આ ઓબ્જેક્ટ ભૌતિકશાસ્ત્રની તપાસ કરે છે કે ખેલાડી જમીન પર standingભો છે કે નહીં. Checkબ્જેક્ટ આ ચેક હાથ ધરવા માટે સક્ષમ થવા માટે, સ્ક્રિપ્ટમાં જોડાણ સ્થાપિત કરવું આવશ્યક છે.
ઉમેરો:
જાહેર પરિવર્તન ગ્રાઉન્ડચેક;
જાહેર ફ્લોટ ગ્રાઉન્ડડિસ્ટન્સ = 0.4 એફ;
એક પણ છે
જાહેર લેયરમાસ્ક ગ્રાઉન્ડમાસ્ક;
તમારે એક ચલની પણ જરૂર છે જે નક્કી કરે છે કે ખેલાડી જમીન પર છે કે નહીં:
બૂલ ગ્રાઉન્ડ છે;
હવે અપડેટ ફંક્શનમાં ઉમેરો આવે છે:
isGrounded = Physics.CheckSphere (groundCheck.position, groundDistance, groundMask);
આ આંકડો જમીન પર છે કે કેમ તે ચકાસવા માટે ભૌતિકશાસ્ત્રનો ઉપયોગ કરે છે. તે ત્યારે થાય છે જ્યારે પદાર્થ અથવા ગોળા જમીન પર સ્થિતિ, અંતર અને માસ્ક હોય.
નવા ગેમઓબ્જેક્ટ સાથે, એક નિર્દિષ્ટ બિંદુ પર એક નાનો અદ્રશ્ય ગોળો બનાવવામાં આવે છે. જો તે ગ્રાઉન્ડમાસ્કમાં હોય તેવી વસ્તુ સાથે ટકરાય, તો ખેલાડી જમીન પર હોય છે. નહિંતર, તે ખેલાડી નથી.
વધુમાં:
જો (isGrounded && velocity.y <0)
{
velocity.y = 2f;
}
આ સાથે તમે ખેલાડીને જમીન પર દબાણ કરો છો.
સ્ક્રિપ્ટ હવે આની જેમ દેખાય છે:
ગ્રાઉન્ડચેકને પ્લેયરસ્ક્રિપ્ટના સંબંધિત ક્ષેત્રમાં ખેંચો.
સ્તર ઉમેરો અથવા જમીન માસ્ક માટે સ્તર બદલવા માટે a તમે ઉપર જમણી બાજુએ નવા સ્તરોને ફરીથી વ્યાખ્યાયિત પણ કરી શકો છો.
તમારે પર્યાવરણને, જે ફ્લોર તરીકે કામ કરવાનું માનવામાં આવે છે, સંબંધિત સ્તરમાં ફેરવવું પડશે.
જો પાત્ર ખૂબ ધીરે ધીરે પડે છે, તો તમે ગુરુત્વાકર્ષણ વધારી શકો છો.
જમ્પિંગ માટે, ઝડપ જમ્પિંગ heightંચાઈ દ્વારા વ્યાખ્યાયિત કરવામાં આવે છે:
ઝડપ = વર્ગમૂળ (જમ્પ heightંચાઈ * -2 * ગુરુત્વાકર્ષણ)
આ માટે તમારે જરૂર છે:
જો (Input.GetButtonDown ("Jump") && isGrounded)
{
velocity.y = Mathf.Sqrt ()
}
હવે તમે જમ્પ heightંચાઈ માટે સાર્વજનિક ચલ ઉમેરો:
જાહેર ફ્લોટ જમ્પહાઇટ = 3 એફ;
પછી તમે બહાર નીકળો: jumpHeight * -2f * ગુરુત્વાકર્ષણ રુટ ખેંચો.
velocity.y = Mathf.Sqrt (jumpHeight * -2f * ગુરુત્વાકર્ષણ)
સમાપ્ત સ્ક્રિપ્ટ આના જેવી દેખાય છે:
કામ પર કૂદકો મારવા માટે, ગ્રાઉન્ડ લેયરને જમીન સોંપવી જોઈએ. નહિંતર સ્ક્રિપ્ટ જમ્પિંગ સાથે કામ કરશે નહીં.