Compartilhe

Você está em: Home » Arquivos de junho 2010

Feliz aniversário

Nosso feliz aniversário vai para o Matheus Willian que começou a estudar a UDK através do blog e já está mandando ver no motor gráfico.

Parabéns Matheus pelos seus 13 anos.



Ler Mais

DOWNLOAD UDK - Junho de 2010: UDKInstall-2010-06-BETA

Ler Mais

Conheça o Mudbox



O software Autodesk® Mudbox™ 2010 é a principal solução de pintura texturizada e escultura digital 3D para os artistas de 3D nos segmentos de jogos, cinema, televisão e design.



Requisitos Minimos:

PROCESSADOR:
Intel® Pentium® IV ou superior com no mínimo 1 GHz

MEMÓRIA RAM:
512 MB RAM

DISCO RÍGIDO:
500 MB de espaço livre em disco

Ler Mais

BRASIL GAME SHOW 2010 (20 E 21 DE NOVEMBRO)


Preparem-se dia 20 e 21 de novembro será realizado no Rio de Janeiro o BRASIL GAME SHOW 2010, a maior feira de games do Brasil. É difícil um evento desse tipo e proporção por aqui então é melhor aproveitar esta oportunidade e comparecer, e este ano promete ser melhor do que o ano passado.



Haverá campeonatos de Street Fighter IV, KOF, Mario Kart e o Campeonato Carioca de Winning eleven, sendo o prêmio para o grande campeão um Playstatio 3, então é melhor começar a praticar!!!


Uma exposição da história do video game, que foi um grande sucesso em 2009, e palestras também farão parte do BRASIL GAME SHOW.



A localização do evento será no Centro de Convenções SulAmérica: Avenida Presidente Vargas, esquina com a Avenida Paulo de Frontin no Centro do Rio.
O Centro de Convenções SulAmérica está situado no Teleporto, na região conhecida como Cidade Nova, bem ao lado da Prefeitura do Rio.
A estação do Metrô Estácio é integrada ao local, além da facilidade de linhas de ônibus na porta para todo o Rio e Grande Rio.


Expositores confirmados:

NCGames, Konami, FNAC, Comix, Beat98, Geneal, Casa Ronald McDonald, Ultra X, Editora Arteccom, Icon Games, Nano Games e ShockGames.



É bom começar a economizar uns trocados, O BRASIL GAMES SHOW promete ser um evento com muitas variedades em produtos relacionados a jogos.

E para aqueles que estudam e querem trabalhar nessa área quem sabe você pode estar numa estande em um futuro evento.

Autor: Jorge Luis Sá Amaral -
AJGames

Ler Mais

Crysis 2 - "Making Of"


Para quem acha que a criação de um jogo pode ser um processo simples. Esse making of mostra a quantidade de pessoas envolvidas só para a produção do trailer.

Isso só mostra o quão importante é a produção de vídeos promocionais na divulgação de um produto.

Ler Mais

TUTORIAL CUSTOM PLAYER (Editor UDK 2010 e UnrealScript)


Autor: Jorge Luis Sá Amaral
http://www.youtube.com/user/ajgamesbr

Nesse tutorial ensinarei a inserir um personagem customizado no UDK 2010, antes você precisa ter seu personagem modelado, animado e exportado no 3ds Max ou Maya, para colocar seu personagem no seu jogo será necessário usar o UnrealScript.
Para quem está começando aconselho a fazer este tutorial:
http://udkbrasil.blogspot.com/2009/12/criando-seu-ambiente-do-inicio-ao-fim-e.html

Nele você aprenderá a criar seu ambiente e organizar as suas pastas que você utilizará no seu jogo. Então eu aconselho antes a seguir o tutorial indicado acima.

O código que vai ser utilizado no tutorial você pode baixar aqui:
http://www.4shared.com/file/6mYM4qvj/CustomGames.html

Com esse código o personagem fica em terceira pessoa e pode utilizar o Shoulder cam, aqui eu explicarei onde você deve alterar para colocar seu personagem no jogo.
O arquivo onde está o código que será alterado é o GamePawn.uc no meu projeto o nome é AJGamesPawn.uc, coloque um nome que tenha a ver com seu jogo.
Pawn é como o UDK chama o player do jogo e é nesse arquivo que você cria seu personagem, suas colisões, animações, etc.


Obs.: Os arquivos .uc podem ser editados ou criados usando o bloco de nota, .txt, renomeie para .uc
Procure os comandos abaixo no arquivo AJGamesPawn.uc:

1 - AnimSets(1)=AnimSet'AJGames.SK_Mesh.PlayerCharAnimSet' (Aqui você chama o animset do seu personagem, animset é o conjunto de animações exportadas no Max ou Maya utilizando o plugin ActorX que é importado no UDK, é necessário obedecer a ordem depois do ' AJGames é o nome do meu pacote .upk, SK_Mesh é o diretório que criei dentro do pacote para importar minhas animações e PlayerCharAnimSet é o nome do animset.

2 - AnimTreeTemplate=AnimTree'AJGames.SK_Mesh.AnimTree_Punk' (Aqui você chama o animTree do seu personagem, animTree são as animações linkadas no seu persoangem o esquema é o mesmo do AnimSet: AJGames é o nome do meu pacote .upk, SK_Mesh é o diretório que criei dentro do pacote para importar minhas animações e AnimTree_PunK é o nome do animTree.

3 - SkeletalMesh=SkeletalMesh'AJGames.SK_Mesh.PlayerChar' (Aqui você chama o seu personagem o skeletalmesh dele, esquema é o mesmo: AJGames é o nome do meu pacote .upk, SK_Mesh é o diretório que criei dentro do pacote para importar minhas animações PlayerChar' é o nome do skeletalmesh.

Os pontos entre os nomes são necessários colocar exemplo: PACOTE.DIR.ANIMISET
Caso você não crie nenhum diretório dentro do seu pacote, não é obrigatório criá-los, sua linha de comando vai ficar assim: PACOTE.ANIMSET

Exemplo do meu jogo:

A ordem você pode ver no seu content browser, a pasta do meu jogo customgames dentro dela tem uma pasta levels, onde salvo meus mapas, e a pasta UPK, onde é salvo os pacotes, AJGames é o pacote onde está o diretório SK_Mesh e dentro dele os animiset, animtree e o sekeletalMesh.
































O skeletalMesh, animtree e o animset dentro do diretório SK_Mesh

Depois de modificado, o código, é preciso compilá-lo abra o UnrealFrontend:

Clique na setinha do Make – Full Recompile e mande compilar.




Resultado da compilação:










Clique em Launch e veja seu personagem na UDK.





Resultado Final:



Links:
3ds Max: http://usa.autodesk.com/adsk/servlet/pc/index?siteID=123112&id=13571450
Maya: http://usa.autodesk.com/adsk/servlet/pc/index?id=13578047&siteID=123112
UDK: http://udk.com
Ler Mais

AJGames é um exemplo claro da capacidade dos brasileiros em desenvolver games.




É com muito orgulho que venho com essa matéria não só dar apoio a galera da AJGAMES, mas mostrar que a iniciativa do Blog UDK BRASIL de concentrar tutoriais e ajudar na formação de grupos de estudos não foi em vão.












A AJGAMES é constituída por estudantes da UDK que começaram o aprendizado do motor gráfico e hoje já vislumbram a possibilidade de entrar para o mercado. No vídeo abaixo, há um teste de câmera sobre um personagem feito por eles. Até agora, na internet, não encontrei ninguém que tenha desenvolvido tal teste.

A parceria que fizemos com a AJGAMES para a produção de tutoriais em português, é muito bem vinda, assim como qualquer esforço para promover o trabalho deles.

Em outras palavras: "É NÓIS P#$%A"

Ler Mais

Ponte de Cabo Frio - 1951

Ler Mais

Guia Técnico de Personagens

(Traduzido pelo Google Chrome)

Personagens Guia Técnico

Documento Resumo: Este documento abrange os personagens do Unreal Engine do ponto de vista técnico. Como tal, é mais voltada para programadores.

Documento Changelog: Criado por Jeff Wilson.

Visão global

Personagens de Unreal são constituídos por duas partes: um peão e um controlador. O Peão é a representação física de um jogador ou personagem não-jogáveis (NPC) do mundo. Ele não sabe a diferença entre ser controlado por um jogador e ser controlada por AI. Os peões têm uma malha, colisão e física que lhes permita lidar com todas as funcionalidades envolvidas com a interação física entre o personagem eo mundo. Eles também contêm funcionalidade para a tomada de dano de outros jogadores ou os seus arredores, fazendo com que sons, animações jogar, e qualquer funcionalidade de inventário, tais como exploração e / ou armas de fogo (embora o processo de queima arma é tecnicamente iniciado a partir da classe do controlador).

Cada peão pode ter um único controlador, a qualquer momento. O controlador, como seu nome sugere, toma cuidado de dizer ao peão o que fazer e como se comportar. É essencialmente o cérebro por trás do Peão. Controladores vêm em diferentes sabores, como PlayerControllers e AIControllers, mas o seu principal objectivo é aceitar a entrada do jogador ou outros estímulos do mundo, que tornam o processo de entrada, e agir em conformidade. Isso geralmente resulta em fazer passar algum comando ou uma série de comandos para o peão.

Sob circunstâncias normais, a classe GameInfo irá lidar com a criação dos controladores para todos os jogadores após o login e depois, quando a partida começa ele cria um peão para cada controlador e atribui a esse controlador. Este último processo é conhecido como posse, como o Peão está possuído pelo e sob o controle do controlador. O processo de criação jogador completo é ilustrado abaixo.

Naturalmente, este não tem de ser o caso. Seu jogo pode consistir em um mundo povoado por NPCs que são mão-colocado no mundo e não foi criado de forma dinâmica. Estes NPCs seria mais provável ser uma subclasse da classe base Peão que lidar com a criação dos seus próprios controladores e atribuir-se ao Controller.

Controladores

Um controlador é um ator não-físico, que é anexado a um peão, a fim de controlar suas ações. Ele usa as informações recebidas a partir do leitor ou do seu entorno e utiliza essa informação para fazer com que o peão se comportar em conformidade. O controlador é responsável pela circulação, seja em reação à entrada de jogador ou atravessando caminhos gerados pelo sistema de navegação e executar ações com base em vários eventos. Quando o peão move-se no jogo, fá-lo porque o controlador disse ele. Controladores de receber notificações de muitos dos eventos que ocorrem para o peão que eles controlam - coisas como ver ou ouvir um inimigo. O controlador utiliza esses eventos para implementar o comportamento adequado para o Peão, em resposta ao evento correspondente.

As duas subclasses principais controladores são PlayerController e AIController. Ao criar seu novo personagem, você vai estender a partir de uma dessas classes, ou uma de suas subclasses, dependendo do tipo de personagem que você está criando.

Controladores, especialmente AIControllers, também fazem uso pesado de membros que permite ao auditor para substituir as funções dentro da mesma classe e mandá-los executar ações diferentes dependendo do estado atual do controlador. Os Estados também oferecem a possibilidade de usar o código latente e funções latentes, como as funções de movimento que os personagens AI utilizar para navegar pelo mundo.

Controlador

A classe Controller base contém funções genéricas e acontecimentos que dizem respeito ao controle de um peão, em geral, e não necessariamente específica para saber se ele é um jogador Peão controlada ou um peão AI-controlada.

Peões e Posse

Estas funções têm a ver com a posse e unpossessing de peões.

  • Possuir inPawn [] [bVehicleTransition] - Este atribui o Peão especificado como Controlador de Peão presente e notifica o peão chamando seu PossessedBy () função.
  • UnPossess - Esta limpa Controladoria Peão referência a esta e notifica o peão já não é controlada por este controlador chamando seu UnPossessedBy () função.

Inventário

Estas funções têm a ver com pickups, armas e funcionalidade inventário específica.

  • RatePickup [PickupHolder] [PickupClass] - Esta é uma chamada a partir do PickupFactory que calcula a conveniência da pickup.
  • HandlePickup [InvetoryItem] - Esta função é um espaço reservado vazio a ser substituído o que lhe permite implementar funcionalidades adicionais para lidar com itens que são apanhados.
  • FireWeaponAt] inActor [ - Esta função faz com que o controlador do Peão de arma de fogo activo actualmente o ator especificado.
  • StopFiring - Isso força o controlador do Peão a parar de disparar arma ativa atualmente.
  • SwitchToBestWeapon] bForceNewWeapon [ - Este calcula que as armas no inventário da Controladoria Peão este é o melhor e torna a arma ativa. As opções de parâmetro bool pode forçar uma arma diferente do que o ativo é actualmente a ser escolhido se a arma é o melhor ativo ou não.
  • ClientSetWeapon [WeaponClass] - Isso força Controladoria Peão que isso mude para a arma especificada, assumindo uma arma desse tipo existe no inventário do Peão de.

Veja a Armas Guia Técnico para mais informações sobre Armas.

Movimento e Navegação

Estas funções têm a ver com o movimento latente Peão possuía todo o mundo, significando um comando é dado para ir para um destino particular e do movimento é automático, sem necessidade de ser atualizado a cada tick.

  • MoveTo [NewDestination] [ViewFocus] [DestinationOffset]] bShouldWalk [ - Isto faz com que o peão para avançar para o destino especificado, ou no deslocamento especificado opcional º, mantendo seu foco no ator dado opcional. Esta função usará a rede de caminho para ajudar o Peão navegar para o destino.
  • MoveToDirectNonPathPos [NewDestination] [ViewFocus] [DestinationOffset]] bShouldWalk [ - Este é idêntica em funcionalidade para MoveTo () exceto que ela só deve ser utilizado quando se deslocam para o objetivo final e não seguir um caminho.
  • MoveToward [NewTarget] [ViewFocus] [DestinationOffset] [bUseStrafing] bShouldWalk [] - Isso faz com que o peão para avançar para o ator dado, especificado como o NewTarget. Esta função irá aproveitar a rede de navegação quando se deslocam para outro peão ou um ator de inventário.
  • FindPathTo SunJavaUpdateSched [] [MaxPathLength] bReturnPartial [] - Este calcula um caminho mais próximo do nó de navegação para o destino dado e retorna o próximo nó ao longo desse caminho.
  • FindPathToward [[anactor] bWeightDetours] [MaxPathLength] bReturnPartial [] - Este calcula um caminho mais próximo do nó de navegação para o ator de dados e retorna o próximo nó ao longo desse caminho.
  • * FindPathTowardNearest [GoalClass] [bWeightDetours] [MaxPathLength]] [bReturnpartial - Este calcula um caminho para o nó mais próximo da classe especificada e retorna o próximo nó ao longo desse caminho.
  • FindPathToIntercept [[penhor] InRouteGoal] [bWeightDetours] [MaxPathLength] bReturnpartial [] - Este calcula um caminho para interceptar o penhor dado como ele se move através do mundo e retorna o próximo nó ao longo desse caminho.
  • PointReachable [SunJavaUpdateSched] - Este retorna se o local especificado é acessado diretamente dado Peão de movimento de recursos do. Esta função pode ser caro e deve ser evitada em favor de ActorReachable () se possível.
  • ActorReachable] anactor [ - Isso retorna se o ator é especificado diretamente alcançável dado Peão de movimento de recursos do. Embora potencialmente mais otimizado do que PointReachable (), esta função também pode ser caro e deve ser usado com moderação.
  • * FindRandomDest - Isso retorna um nó aleatório na rede de navegação. Isso pode ser bom para a criação de um estado onde o personagem perambula pelo mundo.

Veja o Resumo AI para obter mais informações sobre Inteligência Artificial e de navegação.

Câmara / objetivo

As funções desta seção tem a ver com o ponto de vista objetivo e do auditor e seu peão.

  • GetPlayerViewPoint out_Location [] [out_Rotation] - Isso retorna o ponto de vista da Controladoria do Peão. Para os jogadores humanos, este é o ponto de vista da câmera. Para os jogadores controlados AI, este é o ponto de vista do Peão de olhos a. Nesta implementação base, é simplesmente a localização ea rotação do próprio controlador.
  • GetActorEyesViewPoint out_Location [] [out_Rotation] - Isso retorna o ponto de vista do auditor ou do seu peão, se houver. Essencialmente, este retorna sempre que o jogador está olhando e em que direção.
  • IsAimingAt [Alvo] [Epsilon] - Isso retorna se o controlador está a mirar o alvo determinado, dentro de uma determinada quantidade de espaço de manobra. Um Epsilon de 1,0 significa visando diretamente no alvo, enquanto os valores mais baixos permitem algum erro.

Player Controller

O PlayerController e suas subclasses, implementa a funcionalidade para receber a entrada do jogador humano ea transformação que a entrada na ação que você vê no jogo. Para a maior parte dos casos, isso significa que o PlayerController trata ações como mover o peão, o controle da câmera (por meio do Peão), e comutação ou armas de fogo com base nos botões ou teclas, o jogador tem pressionado. Abaixo estão algumas das principais funções das classes PlayerController com as descrições de cada um.

Geral

Essas funções são de natureza geral e não pertencem a nenhuma categoria específica.

  • Playertick [DeltaTime] - Esta é a principal função de atualização para os jogadores. Ele é executado a cada ciclo.
  • ConsoleCommand [Command] - Este executa o comando dado como se fosse um console de comando digitados pelo jogador.

Entrada Player Movimento /

Estas funções pertencem à entrada e circulação do jogador.

  • InitInputSystem - Esta função inicializa o sistema de entrada através da criação de uma nova instância da classe PlayerInput do PlayerController.
  • PlayerMove [DeltaTime] - Este calcula a aceleração de novos valores e rotação para o movimento atual e, em seguida, chama um ProcessMove () (para o single-player ou ouvir servidores) ou ReplicateMove () (para clientes de rede). Isto é simplesmente um esboço na classe PlayerController base, mas é substituído dentro de certos estados que envolvem movimento, tais como o estado PlayerWalking. Essa função é chamado a partir do PlayerTick () função de cada ciclo.
  • ProcessMove [DeltaTime] [newAccel] [DoubleClickMove] [DeltaRot] - Este processa o movimento atual do cliente. Essa função é substituído dentro de certos estados que requerem a funcionalidade especial para o movimento.
  • ReplicateMove [DeltaTime] [newAccel] [DoubleClickMove] [DeltaRot] - Esta função começa o processo de circulação. Ele salva o movimento atual na lista PendingMove, em seguida, chama ProcessMove () e ServerMove () (executados no servidor).
  • ServerMove [Timestamp] [inAccel] [ClientLoc] [MoveFlags] [ClientRoll] [View] - Este é executado apenas no servidor e executa o movimento atual chamando MoveAutonomous (). Ela também determina se uma atualização é necessária dependendo se passou tempo suficiente desde a última atualização, ou se houver erro bastante entre o cliente eo servidor posições.
  • Move Autónoma [DeltaTime] [MoveFlags] [newAccel] [DeltaRot] - Esta chama ProcessMove () e atualizações de todos os cálculos de física autônoma que precisam ser executadas.
  • ClientUpdatePosition - Isso atualiza a posição do jogador no cliente para coincidir com o servidor. Isso é chamado de o PlayerTick () função, mas somente após o ServerMove função () determinou que é necessário.
  • UpdateRotation [DeltaTime] - Isso atualiza a rotação do auditor e da Controladoria do Peão com base em entrada do jogador
  • ProcessViewRotation [DeltaTime] out_ViewRotation [] [DeltaRot] - Esta processos jogador vista a rotatividade com base em jogadores de entrada e saídas resultante da rotação. Isso é chamado de UpdateRotation ().

AI Controller

O AIController e suas subclasses, implementa a funcionalidade para observar o ambiente Peão e tomar decisões inteligentes com base nessa informação. Essencialmente, utiliza a sua própria decisão loop independente para percorrer continuamente o processo de tomada de decisões e realizar as ações apropriadas com base nessas decisões. As principais funções das classes AIController são explicadas abaixo.

Tomada de Decisão

Quando se tratar de entidades AI-controlada, o processo de tomada de decisão é obviamente muito importante. Sem tratamento da informação algo e decidir o que fazer ou como agir com base nessa informação, os seus personagens NPC são realmente nada mais do que estátuas. Obviamente, as discussões de como criar uma boa AI estão bem além do escopo deste documento, mas você ainda precisa saber como e onde adicionar o seu código de AI na estrutura de classes AIController. As funções abaixo são os laboriosos principal no processo de tomada de decisão.

Nota: Estas funções são implementadas na classe UDKBot e não na classe AIController base. Você teria que se estendem desde UDKBot ou UTBot, a fim de fazer uso destes.

  • ExecuteWhatToDoNext - Este é o principal ponto de entrada para o processo de tomada de decisão e deve conter a maior parte da lógica de decisão. Esta função é executada durante o carrapato física, no entanto, assim que não deve conter nada que possa alterar o estado de física.
  • WhatToDoNext - Isto faz com que ExecuteWhatToDoNext () seja chamado durante a escala seguinte e também pode conter qualquer código que não é seguro para realizar durante a escala física. Isso não seria chamado de dentro do código do estado em favor do uso LatentWhatToDonext ().
  • LatentWhatToDoNext - Este encapsula WhatToDoNext chamada () e esperar que o atrasado processo decisório assinalar a ocorrer. Isso é chamado de código de estado para que o estado está em pausa enquanto aguarda a decisão loop seguinte.

Peão

A classe Peão é a classe base para todos os jogadores, os personagens, criaturas e outros tipos de entidades dentro de Unreal. Como já foi mencionado anteriormente, é responsável pela interação física entre o jogador ou AI e do mundo. Ao criar uma classe de Peão de costume, primeiro você quer saber o que a funcionalidade já existe para que você possa tomar decisões apropriadas sobre como substituir a funcionalidade existente para implementar o comportamento que você o desejo de seu novo personagem a ter, bem como o orçamento necessário tempo que será necessário nos casos em que completamente nova funcionalidade talvez precise ser adicionado. Para auxiliar neste processo, as importantes funções da classe Peão são explicados abaixo dividido em categorias de funcionalidade.

Controladores e Posse

Essas funções contêm funcionalidade relacionada com a interação do Peão com controladores e ser possuído e unpossessed.

  • PossessedBy controlador [] [bVehicleTransition] - Isso define o auditor passado como o novo controlador do Peão e executa quaisquer outras ações necessárias ou de inicialização. Isso é chamado pelo auditor quando ele toma posse do Peão.
  • Unpossessed - Esta limpa Peão de Controller e redefine quaisquer outras propriedades relevantes. Isso é chamado de o controlador quando o peão morre, a rodada termina, ou quando o tratamento já não deseja estar na posse do Peão, ou seja, se o auditor quer tomar posse de um peão diferente.
  • SpawnDefaultController - Isso gera uma instância da ControllerClass para o peão, se o peão não tem, actualmente, um controlador, e faz com que o controlador de possuir o Peão. Isso é chamado de Peão de PostBeginPlay a função () para garantir que peões colocados no nível ou peões gerado durante o jogo começar possuído por um auditor.
  • DetatchFromController] bDestroyController [ - Isto faz com que o controlador de já não possuem o peão e, opcionalmente, para destruir o controlador, após a posse está quebrado. Isto é chamado quando o peão morre, é redefinida, está sendo destruído, ou está sendo atribuído um outro controlador.

Inventário e Armas

A maioria das funcionalidades de inventário é tratado pelo InventoryManager do Peão que é gerado no PostBeginPlay () do evento. O peão, no entanto, lidar com algumas das funcionalidades e relés de comandos para o InventoryManager através da utilização de várias funções específicas do estoque também. A classe Peão também contém várias funções relacionadas com as armas e os disparos das armas. Estas funções estão listadas abaixo.

  • AddDefaultInventory - Isso adiciona os itens listados no inventário de estoque padrão de Peão de inventário da. Essa função é chamado a partir do AddDefaultInventory () função da classe GameInfo.
  • CreateInventory [inventoryClass [] bDoNotActivate] - Isso cria uma instância da classe de inventário especificado, adiciona Peão de inventário, e retorna o item novo inventário. Esta função simplesmente passa a chamada para o InventoryManager para lidar com o trabalho real.
  • FindInventoryType [inventoryClass] [bAllowSubclass] - Esta pesquisa é o inventário do Peão de uma instância da classe especificada e retorna esse exemplo, se um for encontrado.
  • TossInventory invenetoryItem [] [forceVelocity] - Isso faz com que o peão para jogar fora o item de inventário especificado com uma velocidade opcional, removendo-o do inventário do Peão.
  • ThrowActiveWeapon - Isto faz com que o peão para jogar a arma atualmente ativos no chão, removendo-o do inventário do Peão. Isso simplesmente passa o comando para o TossInventory () para lidar com o trabalho.
  • SetActiveWeapon] newWeapon [ - Isso define a arma especificada como ativo da arma do Peão. Isso simplesmente passa o comando para o InventoryManager para lidar com o trabalho.
  • PlayWeaponSwitch oldWeapon [] [newWeapon] - Isso é usado para causar o peão para jogar as animações necessárias para mudar a sua arma da arma antiga para a nova arma. Isso é chamado de InventoryManager de ChangeWeapon a função ().
  • StartFire] fireModeNum [ - Isto faz com que o peão para começar a disparar a arma ativa usando o firemode especificado. Isto passa o comando para o Inventorymanager.
  • StopFire] fireModeNum [ - Isto faz com que o peão para parar de disparar a arma ativa e firemode. Esta passa o comando para o InventoryManager.
  • WeaponFired arma [] bViaReplication [] [hitLocation] - Isso é usado para delegar a criação de todos os efeitos relacionados ao disparo da arma ativa. Isto chama ativa arma PlayFireEffects a função ().
  • WeaponStoppedFiring arma [] [bViaReplication] - Isso é usado para delegar a destruição de todos os efeitos relacionados ao disparo da arma ativa. Isto chama ativa arma StopFireEffects a função ().

Levando Dano

A classe Peão contém funcionalidades para a cura, bem como tomar dano de armas e outras circunstâncias. Funções relativas aos danos e à saúde estão listados abaixo.

  • TakeDamage [dano] [instagatedBy] [hitLocation] [dinamismo] [damageType] [hitInfo]] damageCauser [ - Isso diminui a saúde do Peão pela quantidade especificada.
    • Danos - O valor pelo qual a diminuição da saúde.
    • InstigatedBy - O controlador do Peão, que é responsável pelos danos que estão sendo tomadas.
    • HitLocation - A posição de que o dano deve ser aplicada.
    • Momentum - A velocidade a ser aplicado para o peão, como resultado dos danos.
    • DamageType - A classe tipo de dano que descreve o tipo de dano a ser feito.
    • HitInfo - Um TraceHitInfo opcional estrutura de informação sobre os danos.
    • DamageCauser - Um opcional ator responsável pelo dano que está sendo feito.
  • [Montante HealDamage] [curador] [damageType] - Isso aumenta Peão de saúde, até o montante especificado, limitando a quantidade de saúde resultantes de Peão de saúde o máximo e só se o peão não está morto ou já em plena saúde.
  • TakeFallingDamage - Isto aplica-se dano ao Peão baseado na velocidade em que ele está caindo. Esta passa a quantidade adequada de danos ao TakeDamage () função.
  • CrushedBy] otherPawn [ - Isto faz com que o peão para tomar o dano, quando um outro peão se baseado nele. A quantidade de dano é baseado na velocidade do peão que se baseia sobre este peão. Isso é chamado de Peão de BaseChange a função () e passa a quantidade danos ao TakeDamage () função.
  • TakeRadiusDamageOnBones [instigatedBy] [baseDamage] [damageRadius] [damageType] momento [] [hurtOrigin] [bFullDamage] [damageCauser] [] ossos - Esta função aplica um dependente atenuada danos raio para uma lista de ossos específicos sobre o esqueleto malha peão.
  • NotifyTakeHit [instigatedBy] [hitLocation] [dano] [damageType]] momento [ - Esta função envia notificações de tudo o que precisa ser notificado que o peão tem tido prejuízos. Isto exige Controladoria NotifyTakeHit a função ().
  • TakeDrowningDamage - Isto aplica-se danos com base em se o peão está na água e foi debaixo d'água por muito tempo.

Animações

Os peões usam uma malha esquelético como seu principal componente visual. Embora uma grande parte da reprodução de animações para ações tais como o movimento é tratado pelo AnimTree atribuído ao Peão, eles têm algumas funcionalidades limitadas para jogar animações construído dentro Muito disso vem na forma de funções auxiliares que passam comandos para o componente de rede do esqueleto do Peão. Essas funções são descritas a seguir.

Nota: O SkeletalMeshComponent do Peão, referenciado pela variável Mesh, contém funcionalidades relacionadas com a animação para jogar seqüências de animação individual. Tenha em mente que usar isso requer que o nó e uma animação só AnimTree do Peão é um nó AnimNodeSequence. Isto significa que você estaria perdendo toda a funcionalidade avançada do sistema AnimTree, tais como mistura, mas a funcionalidade está presente, se necessário.

  • SetMorphWeight [MorphNodeName] [MorphWieght] - Define o peso de um nó particular morph no AnimTree atribuído ao peão.
  • SetSkelControlScale [SkelControlName] [Scale] - Define a escala de um nó SkelControl especial no AnimTree atribuído ao peão.
  • PlayActorFaceFXAnim [AnimSet] [GroupName] [SeqName] [SoundCueToPlay] - Isso faz com que o peão para jogar o especificado FaceFX seqüência de animação facial.
  • StopActorFaceFXAnim - Isso interrompe a reprodução actualmente FaceFX seqüência de animação facial.
  • IsActorPlayingFaceFXAnim - Isso retorna um valor booleano dizendo se o peão está jogando atualmente uma animação facial FaceFX.

Perspectiva da câmera / objetivo

Essas funções contêm funcionalidade para controlar a posição e orientação da câmera do jogador quando o peão é o alvo de exibição atual, bem como definir o objectivo do actual para o jogador ou NPC.

  • CalcCamera [DeltaTime] [out_CamLoc] [out_CamRot] [out_FOV] - Esta câmera calcula o ponto de vista ao ver do Peão. Este é o cálculo da câmera principal para o jogador.
  • GetDefaultCameraMode controller] [ - Isso retorna o modo de câmera padrão, como o nome, que deve ser usado para este peão. Isso geralmente é chamado pelo controlador quando possuir o Peão.
  • ProcessViewRotation deltaTime [] out_ViewRotation [] [out_DeltaRot] - Este processo de rotação de vista, o jogador retorna a rotação e posição final como parâmetro out_ViewRotation. Isso é chamado de o UpdateRotation () função do PlayerController.
  • SetViewRotation [NewRotation] - Define a rotação do auditor, caso exista, ou do Peão própria se não existe Controller.
  • GetActorEyesViewPoint out_Location [] [out_Rotation] - Isso retorna a localização e orientação do Peão de olhos, ou do ponto de vista do jogador. Para uma perspectiva de primeira pessoa é idêntico para a localização e orientação da câmera. É também o ponto de vista mais traços serão realizadas a partir de.
  • GetBaseAimRotation - Isso retorna a rotação com o objetivo, como Rotator, do Peão, sem quaisquer ajustes, tais como erro objectivo, automático, de adesão, etc
  • GetAdjustedAimFor [arma] [StartFireLoc] - Isso permite que um ponto intermediário para aplicar os ajustes para a rotação objectivo base, como o objectivo de erro, auto-objetivando, etc Por padrão, este passa o comando para o GetAdjustedaimFor () função do auditor. Se nenhum controlador existe para o peão, ele retorna a rotação objectivo base.

Exemplo Player

Para demonstrar a adição de um novo personagem-jogador controlada através de uma malha de costume, três novas classes serão usados: um peão, um PlayerController, e um GameInfo. O objetivo deste exemplo é mostrar o básico de criação de um novo personagem a ser controlado pelo jogador. Depois de ter a implementação básica, é simplesmente uma questão de usar o que está disponível ou adicionar sua própria funcionalidade personalizada para implementar um novo personagem que se adapta o seu jogo.















Player Class Peão

Para este exemplo, a classe Peão novo tem uma funcionalidade pouco acrescentou. Nós decidimos dar-lhe uma característica interna de regeneração da saúde. Dentro do Tick () função, uma quantidade específica de saúde é adicionado à saúde actual do Peão de cada tantas vezes. Para conseguir isso, a classe algumas variáveis foram adicionados e, em seguida, a função Tick foi substituído e da regeneração foi adicionado.

UDNPawn classe estende UTPawn; var float ElapsedRegenTime; var float RegenAmount; RegenTime float var; evento Tick (float DeltaTime) (/ / calcular o tempo decorrido ElapsedRegenTime DeltaTime + = / / tem tempo decorrido? If (ElapsedRegenTime> = RegenTime) (/ / / curar o peão eo tempo decorrido HealDamage reset (RegenAmount, Controller, class'DamageType '); ElapsedRegenTime = 0.0f;)) defaultproperties (/ / definir padrões para as propriedades de regeneração RegenAmount RegenTime = 2 = 1)

Player Class Controller

A classe PlayerController novo é uma extensão muito básico da classe UTPlayerController. Ele simplesmente adiciona uma nova variável de classe para manter a classe do personagem para usar como jogador e em seguida, define que, como o personagem do jogador com o ServerSetCharacterClass existentes () função.

UDNPlayerController classe estende UTPlayerController; var classe  CharacterClass; simulado evento PostBeginPlay () (super.PostBeginPlay (); SetupPlayerCharacter ();) / ** jogador caráter de classe info Set & executar qualquer inicialização outros * / function SetupPlayerCharacter () (/ / / conjunto de caracteres para o nosso caráter personalizado ServerSetCharacterClass (CharacterClass);) defaultproperties (/ / Chama a atenção para a classe UTFamilyInfo para o seu personagem CharacterClass class'UDNExamples = costume. UDNFamilyInfo_SpaceMarine ')

GameInfo Classe

Um novo tipo de jogo é necessário, neste caso, a fim de especificar que o Peão e classes novos PlayerController deve ser usado. Você provavelmente irá utilizar um tipo de jogo personalizado de qualquer maneira na criação de seu jogo usando UDK assim que você apenas adicionar as propriedades padrão adequado para essa classe em vez de criar um novo. Para este exemplo, o tipo de jogo novo é criado e simplesmente define o DefaultPawnClass e propriedades PlayerControllerClass para apontar para o novo Peão e classes PlayerController.

estende UDNGame UTDeathMatch; defaultproperties (/ / Chama a atenção para seu personalizado Peão = DefaultPawnClass class'UDNExamples. UDNPawn classe 'classe / / aponta para o personalizado PlayerControllerClass class = class'UDNExamples PlayerController. UDNPlayerController')

Agora, se corremos um mapa usando esse novo tipo de jogo, o jogador deve regenerar quando danificado e usar o caráter personalizado.

Exemplo NPC

Para demonstrar um simples peão AI-controlada, um peão nova classe Controller e será criado. A classe Peão será placeable dentro Unreal Editor e irá lidar com criação de malha, de animação, propriedades físicas, bem como definir uma classe de controlador de usar. O auditor será responsável por causar o NPC para vaguear ao redor do mundo, escolhendo destinos aleatórios cada vez que chega o atual.










NPC Classe Peão

A classe do penhor é bastante simples. Ela tem um casal de propriedades adicionadas, mas estes são apenas duplicados dos imóveis existentes destinadas a torná-lo fácil de usar para o designer. A SkeletalMeshComponent é usado para configurar todas as propriedades visuais, tais como a malha, AnimTree, AnimSets, PhysicsAsset, etc Alguns valores padrão para isso são fixados no bloco de propriedades padrão. Uma classe é usada para definir a classe de controlador a ser usado para controlar o NPC. O PostBeginPlay () função é usada para definir a variável existente ControllerClass à variável NPCController novo. Finalmente, o SetCharacterClassFromInfo () função é substituído para não fazer nada porque não serão necessários para essa implementação NPC.

A fonte completa para a classe é mostrada aqui:

UDNPawn_NPC classe estende UTPawn placeable; var (NPC) SkeletalMeshComponent NPCMesh; var (NPC) da classe  NPCController; simulado evento PostBeginPlay () (if (NPCController! = None) (/ / definir o ControllerClass existentes para a nossa classe ControllerClass NPCController novo = NPCController;) Super.PostBeginPlay ();) / / substituir para não fazer nada simulado função SetCharacterClassFromInfo (classe  Info) () defaultproperties (/ / Setup NPC malha padrão Begin Object Class Name SkeletalmeshComponent = = = SkeletalMesh NPCMesh0 SkeletalMesh'CH_LIAM_Cathode. "PhysicsAsset Mesh.SK_CH_LIAM_Cathode = PhysicsAsset'CH_AnimCorrupt. AnimSets Mesh.SK_CH_Corrupt_Male_Physics (0) = AnimSet'CH_AnimHuman. Anims.K_AnimHuman_BaseMale 'AnimtreeTemplate = AnimTree'CH_AnimHuman_Tree. AT_CH_Human' (Object NPCMesh End = = Mesh NPCMesh0 Components.Add NPCMesh0 (NPCMesh0) / / Chama a atenção para a sua classe AIController personalizado - como o NPCController valor default = class'Engine. AIController ')

NPC classe Controller

A classe Controller é sobre a aplicação de navegação mais simples possível. O ExecuteWhatToDoNext () função, que é a principal função de tomada de decisão, é substituído para enviar o auditor continuamente em estado de roaming.Este estado apenas verifica se o destino existe ou se o peão alcançou o atual, estabelece um novo destino, se necessário, e, em seguida, diz o controlador de movimento em direção ao destino. Finalmente, o LatentWhatToDoNext () é chamado para fazer o ExecuteWhatToDoNext () função para ser chamado novamente tick seguinte, reiniciando o ciclo de decisão mais uma vez.

A fonte para a classe controlador é mostrado aqui:

UDNBot classe estende UTBot; var Actor Destino; protegido evento ExecuteWhatToDoNext () (/ / Vá para o roaming estado GotoState ("roaming");) (estado Roaming Begin / / Se nós apenas começou e nós chegamos ao destino / / pick um novo destino - se ao acaso (destino == none | | Pawn.ReachedDestination (destino)) (Destino = FindRandomDest ();) / / Encontrar um caminho para o destino e ir para o próximo nó no caminho MoveToward (FindPathToward ( Destino), FindPathToward (destino)); / fogo / off próxima decisão LatentWhatToDoNext loop ();)) (defaultproperties

Agora, é só uma questão até colocar uma instância da classe UDNPawn_NPC em um mapa e testá-lo.

Ler Mais
Assinar: Postagens (Atom)

Fórum UDKBrasil

Top View Semanal

Top View Mensal

Top View de todos os Tempos

 
UDK BRASIL | by TNB ©2010